GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/StringViewTest.cpp Lines: 530 530 100.0 %
Date: 2023-12-13 14:51:09 Branches: 1289 4653 27.7 %

Line Branch Exec Source
1
#include <string>
2
#include <array>
3
4
#include "gtest/gtest.h"
5
6
#include "zserio/StringView.h"
7
8
namespace zserio
9
{
10
11


802
TEST(StringViewTest, ptrConstructor)
12
{
13
1
    const char* str = "everything";
14
1
    StringView sv(str);
15



1
    ASSERT_EQ(str, sv.data());
16



1
    ASSERT_EQ(10, sv.size());
17
}
18
19


802
TEST(StringViewTest, ptrCountConstructor)
20
{
21
1
    const char* str = "everything";
22
1
    StringView sv(str, 9);
23



1
    ASSERT_EQ(str, sv.data());
24



1
    ASSERT_EQ(9, sv.size());
25
}
26
27


802
TEST(StringViewTest, stringConstructor)
28
{
29
2
    std::string str = "everything";
30
1
    StringView sv(str);
31



1
    ASSERT_EQ(str.data(), sv.data());
32



1
    ASSERT_EQ(str.size(), sv.size());
33
}
34
35


802
TEST(StringViewTest, beginEnd)
36
{
37
2
    std::string str = "everything";
38
1
    StringView sv(str);
39
40
1
    auto itStr = str.begin();
41
11
    for (auto it = sv.begin(); it != sv.end(); ++it, ++itStr)
42
    {
43



10
        ASSERT_NE(str.end(), itStr);
44



10
        ASSERT_EQ(*itStr, *it);
45
    }
46
47
1
    itStr = str.begin();
48

11
    for (auto it = sv.cbegin(); it != sv.cend(); ++it, ++itStr)
49
    {
50



10
        ASSERT_NE(str.end(), itStr);
51



10
        ASSERT_EQ(*itStr, *it);
52
    }
53
}
54
55


802
TEST(StringViewTest, rBeginRend)
56
{
57
2
    std::string str = "everything";
58
1
    StringView sv(str);
59
60
1
    auto itStr = str.rbegin();
61

11
    for (auto it = sv.rbegin(); it != sv.rend(); ++it, ++itStr)
62
    {
63



10
        ASSERT_NE(str.rend(), itStr);
64



10
        ASSERT_EQ(*itStr, *it);
65
    }
66
67
1
    itStr = str.rbegin();
68

11
    for (auto it = sv.crbegin(); it != sv.crend(); ++it, ++itStr)
69
    {
70



10
        ASSERT_NE(str.rend(), itStr);
71



10
        ASSERT_EQ(*itStr, *it);
72
    }
73
}
74
75


802
TEST(StringViewTest, arrayAccess)
76
{
77
1
    const char* str = "everything";
78
1
    StringView sv(str);
79
80
11
    for (size_t i = 0; i < sv.size(); ++i)
81
    {
82



10
        ASSERT_EQ(str[i], sv[i]);
83
    }
84
}
85
86


802
TEST(StringViewTest, at)
87
{
88
1
    const char* str = "everything";
89
1
    StringView sv(str);
90
91
11
    for (size_t i = 0; i < sv.size(); ++i)
92
    {
93




10
        ASSERT_EQ(str[i], sv.at(i));
94
    }
95
96









2
    ASSERT_THROW(sv.at(11), CppRuntimeException);
97
}
98
99


802
TEST(StringViewTest, front)
100
{
101
1
    const char* str = "nothing";
102
1
    StringView sv(str);
103



1
    ASSERT_EQ('n', sv.front());
104
}
105
106


802
TEST(StringViewTest, back)
107
{
108
1
    const char* str = "beam";
109
1
    StringView sv(str);
110



1
    ASSERT_EQ('m', sv.back());
111
}
112
113


802
TEST(StringViewTest, data)
114
{
115
1
    const char* str = "Everything";
116
1
    StringView sv(str);
117



1
    ASSERT_EQ(str, sv.data());
118
}
119
120


802
TEST(StringViewTest, size)
121
{
122
1
    const char* str = "Everything";
123
1
    StringView sv(str);
124



1
    ASSERT_EQ(10, sv.size());
125
}
126
127


802
TEST(StringViewTest, length)
128
{
129
1
    const char* str = "Everything";
130
1
    StringView sv(str);
131



1
    ASSERT_EQ(10, sv.length());
132
}
133
134


802
TEST(StringViewTest, maxSize)
135
{
136
1
    const char* str = "Everything";
137
1
    StringView sv(str);
138



1
    ASSERT_LE(1U << 16U, sv.max_size());
139
}
140
141


802
TEST(StringViewTest, empty)
142
{
143
1
    const char* str = "Everything";
144
1
    StringView sv(str);
145
1
    StringView svEmpty;
146



1
    ASSERT_FALSE(sv.empty());
147



1
    ASSERT_TRUE(svEmpty.empty());
148
}
149
150


802
TEST(StringViewTest, removePrefix)
151
{
152
1
    const char* str = "Everything";
153
1
    StringView sv(str);
154
155
1
    sv.remove_prefix(2);
156



1
    ASSERT_EQ(8, sv.size());
157



1
    ASSERT_EQ(str + 2, sv.data());
158
159
1
    sv.remove_prefix(8);
160



1
    ASSERT_TRUE(sv.empty());
161
}
162
163


802
TEST(StringViewTest, removeSuffix)
164
{
165
1
    const char* str = "Everything";
166
1
    StringView sv(str);
167
168
1
    sv.remove_suffix(2);
169



1
    ASSERT_EQ(8, sv.size());
170



1
    ASSERT_EQ(str, sv.data());
171
172
1
    sv.remove_suffix(8);
173



1
    ASSERT_TRUE(sv.empty());
174
}
175
176


802
TEST(StringViewTest, swap)
177
{
178
1
    const char* str1 = "everything";
179
1
    const char* str2 = "another string";
180
1
    StringView sv1(str1);
181
1
    StringView sv2(str2);
182
1
    sv1.swap(sv2);
183



1
    ASSERT_EQ(14, sv1.size());
184



1
    ASSERT_EQ(10, sv2.size());
185



1
    ASSERT_EQ(str2, sv1.data());
186



1
    ASSERT_EQ(str1, sv2.data());
187
}
188
189


802
TEST(StringViewTest, copy)
190
{
191
1
    const char* str = "everything";
192
1
    StringView sv(str);
193
1
    std::array<char, 6> buffer = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
194
1
    sv.copy(buffer.data(), buffer.size() - 1, 1);
195



1
    ASSERT_EQ('v', buffer[0]);
196



1
    ASSERT_EQ('e', buffer[1]);
197



1
    ASSERT_EQ('r', buffer[2]);
198



1
    ASSERT_EQ('y', buffer[3]);
199



1
    ASSERT_EQ('t', buffer[4]);
200



1
    ASSERT_EQ(0x55, buffer[5]);
201









2
    ASSERT_THROW(sv.copy(buffer.data(), buffer.size() - 1, 11), CppRuntimeException);
202
}
203
204


802
TEST(StringViewTest, substr)
205
{
206
1
    const char* str = "everything";
207
1
    StringView sv(str);
208
1
    StringView subView = sv.substr(2, 5);
209



1
    ASSERT_EQ(5, subView.size());
210



1
    ASSERT_EQ(str + 2, subView.data());
211
212









2
    ASSERT_THROW(sv.substr(11), CppRuntimeException);
213
}
214
215


802
TEST(StringViewTest, compareStringView)
216
{
217
1
    StringView aaa("aaa");
218
1
    StringView bbb("bbb");
219
1
    StringView aaaa("aaaa");
220
1
    StringView aa("aa");
221
222



1
    ASSERT_LT(0, bbb.compare(aaa));
223



1
    ASSERT_GT(0, aaa.compare(bbb));
224



1
    ASSERT_EQ(0, aaa.compare(aaa));
225



1
    ASSERT_LT(0, aaa.compare(aa));
226



1
    ASSERT_GT(0, aaa.compare(aaaa));
227
}
228
229


802
TEST(StringViewTest, compareStringViewSub)
230
{
231
1
    StringView aaa("aaa");
232
1
    StringView saaas("saaas");
233
1
    StringView bbb("bbb");
234
1
    StringView sbbbs("sbbbs");
235
1
    StringView aaaa("aaaa");
236
1
    StringView aa("aa");
237
238



1
    ASSERT_LT(0, sbbbs.compare(1, 3, aaa));
239



1
    ASSERT_GT(0, saaas.compare(1, 3, bbb));
240



1
    ASSERT_EQ(0, saaas.compare(1, 3, aaa));
241



1
    ASSERT_LT(0, saaas.compare(1, 3, aa));
242



1
    ASSERT_GT(0, saaas.compare(1, 3, aaaa));
243
}
244
245


802
TEST(StringViewTest, compareStringViewSubSub)
246
{
247
1
    StringView aaa("aaa");
248
1
    StringView saaas("saaas");
249
1
    StringView bbb("bbb");
250
1
    StringView sbbbs("sbbbs");
251
1
    StringView saaaas("saaaas");
252
253



1
    ASSERT_LT(0, sbbbs.compare(1, 3, saaas, 1, 3));
254



1
    ASSERT_GT(0, saaas.compare(1, 3, sbbbs, 1, 3));
255



1
    ASSERT_EQ(0, saaas.compare(1, 3, saaas, 1, 3));
256



1
    ASSERT_LT(0, saaas.compare(1, 3, saaas, 1, 2));
257



1
    ASSERT_GT(0, saaas.compare(1, 3, saaaas, 1, 4));
258
}
259
260


802
TEST(StringViewTest, compareChar)
261
{
262
1
    StringView aaa("aaa");
263
1
    StringView bbb("bbb");
264
265



1
    ASSERT_LT(0, bbb.compare("aaa"));
266



1
    ASSERT_GT(0, aaa.compare("bbb"));
267



1
    ASSERT_EQ(0, aaa.compare("aaa"));
268



1
    ASSERT_LT(0, aaa.compare("aa"));
269



1
    ASSERT_GT(0, aaa.compare("aaaa"));
270
}
271
272


802
TEST(StringViewTest, compareCharSub)
273
{
274
1
    StringView saaas("saaas");
275
1
    StringView sbbbs("sbbbs");
276
277



1
    ASSERT_LT(0, sbbbs.compare(1, 3, "aaa"));
278



1
    ASSERT_GT(0, saaas.compare(1, 3, "bbb"));
279



1
    ASSERT_EQ(0, saaas.compare(1, 3, "aaa"));
280



1
    ASSERT_LT(0, saaas.compare(1, 3, "aa"));
281



1
    ASSERT_GT(0, saaas.compare(1, 3, "aaaa"));
282
}
283
284


802
TEST(StringViewTest, compareCharSubSub)
285
{
286
1
    StringView saaas("saaas");
287
1
    StringView sbbbs("sbbbs");
288
289



1
    ASSERT_LT(0, sbbbs.compare(1, 3, "aaas", 3));
290



1
    ASSERT_GT(0, saaas.compare(1, 3, "bbbs", 3));
291



1
    ASSERT_EQ(0, saaas.compare(1, 3, "aaas", 3));
292



1
    ASSERT_LT(0, saaas.compare(1, 3, "aaas", 2));
293



1
    ASSERT_GT(0, saaas.compare(1, 3, "aaaas", 4));
294
}
295
296


802
TEST(StringViewTest, find)
297
{
298
1
    StringView str("karkarbanatek");
299
300
1
    StringView search1("karbanatekkarbanatek");
301



1
    ASSERT_EQ(StringView::npos, str.find(search1, 0));
302



1
    ASSERT_EQ(StringView::npos, str.find(search1, 9999));
303
304
1
    StringView search2("");
305



1
    ASSERT_EQ(0, str.find(search2, 0));
306
307
1
    StringView search3("kar");
308



1
    ASSERT_EQ(0, str.find(search3, 0));
309



1
    ASSERT_EQ(3, str.find(search3, 1));
310



1
    ASSERT_EQ(3, str.find(search3, 3));
311



1
    ASSERT_EQ(StringView::npos, str.find(search3, 4));
312
313
1
    StringView search4("ban");
314



1
    ASSERT_EQ(6, str.find(search4, 0));
315



1
    ASSERT_EQ(6, str.find(search4, 6));
316



1
    ASSERT_EQ(StringView::npos, str.find(search4, 7));
317
318
1
    StringView search5("tek");
319



1
    ASSERT_EQ(10, str.find(search5, 0));
320



1
    ASSERT_EQ(10, str.find(search5, 10));
321



1
    ASSERT_EQ(StringView::npos, str.find(search5, 11));
322
323
1
    StringView search6("tekk");
324



1
    ASSERT_EQ(StringView::npos, str.find(search6, 0));
325



1
    ASSERT_EQ(StringView::npos, str.find(search6, 10));
326



1
    ASSERT_EQ(StringView::npos, str.find(search6, 11));
327
328
1
    StringView search7("ana");
329



1
    ASSERT_EQ(7, str.find(search7, 0));
330



1
    ASSERT_EQ(7, str.find(search7, 7));
331



1
    ASSERT_EQ(StringView::npos, str.find(search7, 8));
332
}
333
334


802
TEST(StringViewTest, findChar)
335
{
336
1
    StringView str("karkarbanatek");
337
338
1
    StringView search2("");
339



1
    ASSERT_EQ(0, str.find(search2, 0));
340
341



1
    ASSERT_EQ(0, str.find('k', 0));
342



1
    ASSERT_EQ(3, str.find('k', 1));
343



1
    ASSERT_EQ(12, str.find('k', 5));
344



1
    ASSERT_EQ(StringView::npos, str.find('m', 0));
345
}
346
347


802
TEST(StringViewTest, findCharStrLen)
348
{
349
1
    StringView str("karkarbanatek");
350
351



1
    ASSERT_EQ(StringView::npos, str.find("karbanatekkarbanatek", 0, 21));
352



1
    ASSERT_EQ(StringView::npos, str.find("karbanatekkarbanatek", 9999, 21));
353
354



1
    ASSERT_EQ(0, str.find("", 0, 0));
355
356



1
    ASSERT_EQ(0, str.find("kar", 0, 3));
357



1
    ASSERT_EQ(3, str.find("kar", 1, 3));
358



1
    ASSERT_EQ(3, str.find("kar", 3, 3));
359



1
    ASSERT_EQ(StringView::npos, str.find("kar", 4, 3));
360
361



1
    ASSERT_EQ(6, str.find("ban", 0, 3));
362



1
    ASSERT_EQ(6, str.find("ban", 6, 3));
363



1
    ASSERT_EQ(StringView::npos, str.find("ban", 7, 3));
364
365



1
    ASSERT_EQ(10, str.find("tek", 0, 3));
366



1
    ASSERT_EQ(10, str.find("tek", 10, 3));
367



1
    ASSERT_EQ(StringView::npos, str.find("tek", 11, 3));
368
369



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 0, 4));
370



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 10, 4));
371



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 11, 4));
372
}
373
374


802
TEST(StringViewTest, findCharStr)
375
{
376
1
    StringView str("karkarbanatek");
377
378



1
    ASSERT_EQ(StringView::npos, str.find("karbanatekkarbanatek", 0));
379



1
    ASSERT_EQ(StringView::npos, str.find("karbanatekkarbanatek", 9999));
380
381



1
    ASSERT_EQ(0, str.find("", 0));
382
383



1
    ASSERT_EQ(0, str.find("kar", 0));
384



1
    ASSERT_EQ(3, str.find("kar", 1));
385



1
    ASSERT_EQ(3, str.find("kar", 3));
386



1
    ASSERT_EQ(StringView::npos, str.find("kar", 4));
387
388



1
    ASSERT_EQ(6, str.find("ban", 0));
389



1
    ASSERT_EQ(6, str.find("ban", 6));
390



1
    ASSERT_EQ(StringView::npos, str.find("ban", 7));
391
392



1
    ASSERT_EQ(10, str.find("tek", 0));
393



1
    ASSERT_EQ(10, str.find("tek", 10));
394



1
    ASSERT_EQ(StringView::npos, str.find("tek", 11));
395
396



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 0));
397



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 10));
398



1
    ASSERT_EQ(StringView::npos, str.find("tekk", 11));
399
}
400
401


802
TEST(StringViewTest, rfind)
402
{
403
1
    StringView str("karkarbanatek");
404
405
1
    StringView search1("karbanatekkarbanatek");
406



1
    ASSERT_EQ(StringView::npos, str.rfind(search1, 0));
407



1
    ASSERT_EQ(StringView::npos, str.rfind(search1, 9999));
408
409
1
    StringView search2("");
410



1
    ASSERT_EQ(12, str.rfind(search2, 12));
411
412
1
    StringView search3("kar");
413



1
    ASSERT_EQ(3, str.rfind(search3, 12));
414



1
    ASSERT_EQ(3, str.rfind(search3, 3));
415



1
    ASSERT_EQ(0, str.rfind(search3, 2));
416



1
    ASSERT_EQ(0, str.rfind(search3, 0));
417
418
1
    StringView search4("ban");
419



1
    ASSERT_EQ(6, str.rfind(search4, 12));
420



1
    ASSERT_EQ(6, str.rfind(search4, 6));
421



1
    ASSERT_EQ(StringView::npos, str.rfind(search4, 5));
422
423
1
    StringView search5("tek");
424



1
    ASSERT_EQ(10, str.rfind(search5, 12));
425



1
    ASSERT_EQ(10, str.rfind(search5, 10));
426



1
    ASSERT_EQ(StringView::npos, str.rfind(search5, 9));
427
428
1
    StringView search6("tekk");
429



1
    ASSERT_EQ(StringView::npos, str.rfind(search6, 12));
430



1
    ASSERT_EQ(StringView::npos, str.rfind(search6, 10));
431



1
    ASSERT_EQ(StringView::npos, str.rfind(search6, 6));
432
}
433
434


802
TEST(StringViewTest, rFindChar)
435
{
436
1
    StringView str("karkarbanatek");
437
438
1
    StringView search2("");
439



1
    ASSERT_EQ(10, str.rfind(search2, 10));
440
441



1
    ASSERT_EQ(12, str.rfind('k', 12));
442



1
    ASSERT_EQ(3, str.rfind('k', 11));
443



1
    ASSERT_EQ(0, str.rfind('k', 2));
444
445



1
    ASSERT_EQ(StringView::npos, str.rfind('m', 12));
446
}
447
448


802
TEST(StringViewTest, rFindCharStr)
449
{
450
1
    StringView str("karkarbanatek");
451
452



1
    ASSERT_EQ(StringView::npos, str.rfind("karbanatekkarbanatek", 0));
453



1
    ASSERT_EQ(StringView::npos, str.rfind("karbanatekkarbanatek", 9999));
454
455



1
    ASSERT_EQ(12, str.rfind("", 12));
456
457



1
    ASSERT_EQ(3, str.rfind("kar", 12));
458



1
    ASSERT_EQ(3, str.rfind("kar", 3));
459



1
    ASSERT_EQ(0, str.rfind("kar", 2));
460



1
    ASSERT_EQ(0, str.rfind("kar", 0));
461
462



1
    ASSERT_EQ(6, str.rfind("ban", 12));
463



1
    ASSERT_EQ(6, str.rfind("ban", 6));
464



1
    ASSERT_EQ(StringView::npos, str.rfind("ban", 5));
465
466



1
    ASSERT_EQ(10, str.rfind("tek", 12));
467



1
    ASSERT_EQ(10, str.rfind("tek", 10));
468



1
    ASSERT_EQ(StringView::npos, str.rfind("tek", 9));
469
470



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 12));
471



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 10));
472



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 6));
473
}
474
475


802
TEST(StringViewTest, rFindCharStrLen)
476
{
477
1
    StringView str("karkarbanatek");
478
479



1
    ASSERT_EQ(StringView::npos, str.rfind("karbanatekkarbanatek", 0, 20));
480



1
    ASSERT_EQ(StringView::npos, str.rfind("karbanatekkarbanatek", 9999, 20));
481
482



1
    ASSERT_EQ(12, str.rfind("", 12, 0));
483
484



1
    ASSERT_EQ(3, str.rfind("kar", 12, 3));
485



1
    ASSERT_EQ(3, str.rfind("kar", 3, 3));
486



1
    ASSERT_EQ(0, str.rfind("kar", 2, 3));
487



1
    ASSERT_EQ(0, str.rfind("kar", 0, 3));
488
489



1
    ASSERT_EQ(6, str.rfind("ban", 12, 3));
490



1
    ASSERT_EQ(6, str.rfind("ban", 6, 3));
491



1
    ASSERT_EQ(StringView::npos, str.rfind("ban", 5, 3));
492
493



1
    ASSERT_EQ(10, str.rfind("tek", 12, 3));
494



1
    ASSERT_EQ(10, str.rfind("tek", 10, 3));
495



1
    ASSERT_EQ(StringView::npos, str.rfind("tek", 9, 3));
496
497



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 12, 4));
498



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 10, 4));
499



1
    ASSERT_EQ(StringView::npos, str.rfind("tekk", 6, 4));
500
}
501
502


802
TEST(StringViewTest, findFirstOf)
503
{
504
1
    StringView str("karbanatekx");
505
506



1
    ASSERT_EQ(StringView::npos, str.find_first_of(StringView(""), 0));
507



1
    ASSERT_EQ(StringView::npos, str.find_first_of(StringView("pqs"), 0));
508



1
    ASSERT_EQ(StringView::npos, str.find_first_of(StringView("kbt"), 11));
509
510



1
    ASSERT_EQ(0, str.find_first_of(StringView("kbt"), 0));
511



1
    ASSERT_EQ(3, str.find_first_of(StringView("kbt"), 1));
512



1
    ASSERT_EQ(3, str.find_first_of(StringView("kbt"), 3));
513



1
    ASSERT_EQ(7, str.find_first_of(StringView("kbt"), 4));
514



1
    ASSERT_EQ(7, str.find_first_of(StringView("kbt"), 7));
515



1
    ASSERT_EQ(9, str.find_first_of(StringView("kbt"), 8));
516



1
    ASSERT_EQ(9, str.find_first_of(StringView("kbt"), 9));
517



1
    ASSERT_EQ(StringView::npos, str.find_first_of(StringView("kbt"), 10));
518
}
519
520


802
TEST(StringViewTest, findFirstOfChar)
521
{
522
1
    StringView str("karbanatekx");
523
524



1
    ASSERT_EQ(StringView::npos, str.find_first_of('s', 0));
525



1
    ASSERT_EQ(StringView::npos, str.find_first_of('k', 11));
526
527



1
    ASSERT_EQ(0, str.find_first_of('k', 0));
528



1
    ASSERT_EQ(3, str.find_first_of('b', 0));
529



1
    ASSERT_EQ(3, str.find_first_of('b', 3));
530



1
    ASSERT_EQ(StringView::npos, str.find_first_of('b', 4));
531



1
    ASSERT_EQ(StringView::npos, str.find_first_of('k', 10));
532
}
533
534


802
TEST(StringViewTest, findFirstOfCharStr)
535
{
536
1
    StringView str("karbanatekx");
537
538



1
    ASSERT_EQ(StringView::npos, str.find_first_of("", 0));
539



1
    ASSERT_EQ(StringView::npos, str.find_first_of("pqs", 0));
540



1
    ASSERT_EQ(StringView::npos, str.find_first_of("kbt", 11));
541
542



1
    ASSERT_EQ(0, str.find_first_of("kbt", 0));
543



1
    ASSERT_EQ(3, str.find_first_of("kbt", 1));
544



1
    ASSERT_EQ(3, str.find_first_of("kbt", 3));
545



1
    ASSERT_EQ(7, str.find_first_of("kbt", 4));
546



1
    ASSERT_EQ(7, str.find_first_of("kbt", 7));
547



1
    ASSERT_EQ(9, str.find_first_of("kbt", 8));
548



1
    ASSERT_EQ(9, str.find_first_of("kbt", 9));
549



1
    ASSERT_EQ(StringView::npos, str.find_first_of("kbt", 10));
550
}
551
552


802
TEST(StringViewTest, findFirstOfCharStrLen)
553
{
554
1
    StringView str("karbanatekx");
555
556



1
    ASSERT_EQ(StringView::npos, str.find_first_of("", 0, 0));
557



1
    ASSERT_EQ(StringView::npos, str.find_first_of("pqs", 0, 3));
558



1
    ASSERT_EQ(StringView::npos, str.find_first_of("kbt", 11, 3));
559
560



1
    ASSERT_EQ(0, str.find_first_of("kbt", 0, 3));
561



1
    ASSERT_EQ(3, str.find_first_of("kbt", 1, 3));
562



1
    ASSERT_EQ(3, str.find_first_of("kbt", 3, 3));
563



1
    ASSERT_EQ(7, str.find_first_of("kbt", 4, 3));
564



1
    ASSERT_EQ(7, str.find_first_of("kbt", 7, 3));
565



1
    ASSERT_EQ(9, str.find_first_of("kbt", 8, 3));
566



1
    ASSERT_EQ(9, str.find_first_of("kbt", 9, 3));
567



1
    ASSERT_EQ(StringView::npos, str.find_first_of("kbt", 10, 3));
568
}
569
570


802
TEST(StringViewTest, findLastOf)
571
{
572
1
    StringView str("karbanatekx");
573
574



1
    ASSERT_EQ(StringView::npos, str.find_last_of(StringView(""), 10));
575



1
    ASSERT_EQ(StringView::npos, str.find_last_of(StringView("pqs"), 10));
576
577



1
    ASSERT_EQ(9, str.find_last_of(StringView("kbt"), 10));
578



1
    ASSERT_EQ(9, str.find_last_of(StringView("kbt"), 9));
579



1
    ASSERT_EQ(3, str.find_last_of(StringView("kbt"), 4));
580



1
    ASSERT_EQ(3, str.find_last_of(StringView("kbt"), 3));
581



1
    ASSERT_EQ(0, str.find_last_of(StringView("kbt"), 2));
582



1
    ASSERT_EQ(0, str.find_last_of(StringView("kbt"), 1));
583



1
    ASSERT_EQ(0, str.find_last_of(StringView("kbt"), 0));
584
585
1
    StringView empty("");
586



1
    ASSERT_EQ(StringView::npos, empty.find_last_of(StringView("text"), 0));
587



1
    ASSERT_EQ(StringView::npos, empty.find_last_of(StringView(""), 0));
588
}
589
590


802
TEST(StringViewTest, findLastOfChar)
591
{
592
1
    StringView str("karbanatekx");
593
594



1
    ASSERT_EQ(StringView::npos, str.find_last_of('s', 10));
595
596



1
    ASSERT_EQ(8, str.find_last_of('e', 10));
597



1
    ASSERT_EQ(8, str.find_last_of('e', 9));
598



1
    ASSERT_EQ(8, str.find_last_of('e', 8));
599



1
    ASSERT_EQ(StringView::npos, str.find_last_of('e', 7));
600
}
601
602


802
TEST(StringViewTest, findLastOfCharStrLen)
603
{
604
1
    StringView str("karbanatekx");
605
606



1
    ASSERT_EQ(StringView::npos, str.find_last_of("", 10, 0));
607



1
    ASSERT_EQ(StringView::npos, str.find_last_of("pqs", 10, 3));
608
609



1
    ASSERT_EQ(9, str.find_last_of("kbt", 10, 3));
610



1
    ASSERT_EQ(9, str.find_last_of("kbt", 9, 3));
611



1
    ASSERT_EQ(3, str.find_last_of("kbt", 4, 3));
612



1
    ASSERT_EQ(3, str.find_last_of("kbt", 3, 3));
613



1
    ASSERT_EQ(0, str.find_last_of("kbt", 2, 3));
614



1
    ASSERT_EQ(0, str.find_last_of("kbt", 1, 3));
615



1
    ASSERT_EQ(0, str.find_last_of("kbt", 0, 3));
616
}
617
618


802
TEST(StringViewTest, findLastOfCharStr)
619
{
620
1
    StringView str("karbanatekx");
621
622



1
    ASSERT_EQ(StringView::npos, str.find_last_of("", 10));
623



1
    ASSERT_EQ(StringView::npos, str.find_last_of("pqs", 10));
624
625



1
    ASSERT_EQ(9, str.find_last_of("kbt", 10));
626



1
    ASSERT_EQ(9, str.find_last_of("kbt", 9));
627



1
    ASSERT_EQ(3, str.find_last_of("kbt", 4));
628



1
    ASSERT_EQ(3, str.find_last_of("kbt", 3));
629



1
    ASSERT_EQ(0, str.find_last_of("kbt", 2));
630



1
    ASSERT_EQ(0, str.find_last_of("kbt", 1));
631



1
    ASSERT_EQ(0, str.find_last_of("kbt", 0));
632
}
633
634


802
TEST(StringViewTest, findFirstNotOf)
635
{
636
1
    StringView str("karbanatekx");
637
638



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of(StringView(""), 0));
639



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of(StringView("karbntex"), 0));
640



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of(StringView("pqs"), 11));
641
642



1
    ASSERT_EQ(0, str.find_first_not_of(StringView("arb"), 0));
643



1
    ASSERT_EQ(5, str.find_first_not_of(StringView("arb"), 1));
644



1
    ASSERT_EQ(5, str.find_first_not_of(StringView("arb"), 5));
645



1
    ASSERT_EQ(7, str.find_first_not_of(StringView("arb"), 6));
646



1
    ASSERT_EQ(7, str.find_first_not_of(StringView("arb"), 7));
647



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of(StringView("tekx"), 8));
648
}
649
650


802
TEST(StringViewTest, findFirstNotOfChar)
651
{
652
1
    StringView str("karbanatekx");
653
654



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of('m', 11));
655



1
    ASSERT_EQ(0, str.find_first_not_of('m', 0));
656



1
    ASSERT_EQ(0, str.find_first_not_of('a', 0));
657



1
    ASSERT_EQ(2, str.find_first_not_of('a', 1));
658



1
    ASSERT_EQ(7, str.find_first_not_of('a', 7));
659
}
660
661


802
TEST(StringViewTest, findFirstNotOfCharStrLen)
662
{
663
1
    StringView str("karbanatekx");
664
665



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("", 0, 0));
666



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("karbntex", 0, 8));
667



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("pqs", 11, 3));
668
669



1
    ASSERT_EQ(0, str.find_first_not_of("arb", 0, 3));
670



1
    ASSERT_EQ(5, str.find_first_not_of("arb", 1, 3));
671



1
    ASSERT_EQ(5, str.find_first_not_of("arb", 5, 3));
672



1
    ASSERT_EQ(7, str.find_first_not_of("arb", 6, 3));
673



1
    ASSERT_EQ(7, str.find_first_not_of("arb", 7, 3));
674



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("tekx", 8, 4));
675
}
676
677


802
TEST(StringViewTest, findFirstNotOfCharStr)
678
{
679
1
    StringView str("karbanatekx");
680
681



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("", 0));
682



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("karbntex", 0));
683



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("pqs", 11));
684
685



1
    ASSERT_EQ(0, str.find_first_not_of("arb", 0));
686



1
    ASSERT_EQ(5, str.find_first_not_of("arb", 1));
687



1
    ASSERT_EQ(5, str.find_first_not_of("arb", 5));
688



1
    ASSERT_EQ(7, str.find_first_not_of("arb", 6));
689



1
    ASSERT_EQ(7, str.find_first_not_of("arb", 7));
690



1
    ASSERT_EQ(StringView::npos, str.find_first_not_of("tekx", 8));
691
}
692
693


802
TEST(StringViewTest, findLastNotOf)
694
{
695
1
    StringView str("karbanatekx");
696
697



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of(StringView(""), 10));
698



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of(StringView("karbntex"), 10));
699
700



1
    ASSERT_EQ(10, str.find_last_not_of(StringView("arb"), 10));
701



1
    ASSERT_EQ(9, str.find_last_not_of(StringView("arb"), 9));
702



1
    ASSERT_EQ(5, str.find_last_not_of(StringView("arb"), 6));
703



1
    ASSERT_EQ(5, str.find_last_not_of(StringView("arb"), 5));
704



1
    ASSERT_EQ(0, str.find_last_not_of(StringView("arb"), 4));
705



1
    ASSERT_EQ(0, str.find_last_not_of(StringView("arb"), 0));
706
707
1
    StringView empty("");
708



1
    ASSERT_EQ(StringView::npos, empty.find_last_not_of(StringView("text"), 0));
709



1
    ASSERT_EQ(StringView::npos, empty.find_last_not_of(StringView(""), 0));
710
}
711
712


802
TEST(StringViewTest, findLastNotOfChar)
713
{
714
1
    StringView str("karbanatekx");
715
716



1
    ASSERT_EQ(10, str.find_last_not_of('m', 10));
717



1
    ASSERT_EQ(8, str.find_last_not_of('k', 9));
718



1
    ASSERT_EQ(7, str.find_last_not_of('e', 8));
719



1
    ASSERT_EQ(3, str.find_last_not_of('e', 3));
720



1
    ASSERT_EQ(2, str.find_last_not_of('b', 3));
721



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of('k', 0));
722
}
723
724


802
TEST(StringViewTest, findLastNotOfCharStrLen)
725
{
726
1
    StringView str("karbanatekx");
727
728



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of("", 10, 0));
729



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of("karbntex", 10, 8));
730
731



1
    ASSERT_EQ(10, str.find_last_not_of("arb", 10, 3));
732



1
    ASSERT_EQ(9, str.find_last_not_of("arb", 9, 3));
733



1
    ASSERT_EQ(5, str.find_last_not_of("arb", 6, 3));
734



1
    ASSERT_EQ(5, str.find_last_not_of("arb", 5, 3));
735



1
    ASSERT_EQ(0, str.find_last_not_of("arb", 4, 3));
736



1
    ASSERT_EQ(0, str.find_last_not_of("arb", 0, 3));
737
}
738
739


802
TEST(StringViewTest, findLastNotOfCharStr)
740
{
741
1
    StringView str("karbanatekx");
742
743



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of("", 10));
744



1
    ASSERT_EQ(StringView::npos, str.find_last_not_of("karbntex", 10));
745
746



1
    ASSERT_EQ(10, str.find_last_not_of("arb", 10));
747



1
    ASSERT_EQ(9, str.find_last_not_of("arb", 9));
748



1
    ASSERT_EQ(5, str.find_last_not_of("arb", 6));
749



1
    ASSERT_EQ(5, str.find_last_not_of("arb", 5));
750



1
    ASSERT_EQ(0, str.find_last_not_of("arb", 4));
751



1
    ASSERT_EQ(0, str.find_last_not_of("arb", 0));
752
}
753
754


802
TEST(StringViewTest, comparisonOperator)
755
{
756
1
    StringView str1("text");
757
1
    StringView str2("text");
758
1
    StringView str3("texts");
759



1
    ASSERT_TRUE(str1 == str2);
760



1
    ASSERT_TRUE(str1 != str3);
761



1
    ASSERT_TRUE(str1 < str3);
762



1
    ASSERT_TRUE(str1 <= str3);
763



1
    ASSERT_TRUE(str3 > str2);
764



1
    ASSERT_TRUE(str3 >= str2);
765
}
766
767


802
TEST(StringViewTest, makeStringView)
768
{
769
1
    StringView str1 = makeStringView("text");
770
1
    char textWithoutTermZero[] = {'t', 'e', 'x', 't'};
771
1
    StringView str2 = makeStringView(textWithoutTermZero);
772



1
    ASSERT_EQ(str1, str2);
773
774
1
    StringView empty = makeStringView("");
775



1
    ASSERT_EQ(""_sv, empty);
776
}
777
778


802
TEST(StringViewTest, stringViewToString)
779
{
780
1
    StringView str("text");
781
2
    const std::string convertedStr = stringViewToString(str);
782



1
    ASSERT_EQ("text", convertedStr);
783
}
784
785


802
TEST(StringViewTest, appendStringViewToString)
786
{
787
1
    StringView str("text");
788
2
    std::string convertedStr("another ");
789
1
    convertedStr += str;
790



1
    ASSERT_EQ("another text", convertedStr);
791
}
792
793


802
TEST(StringViewTest, toString)
794
{
795
1
    StringView str("text");
796
2
    const std::string convertedStr = toString(str);
797



1
    ASSERT_EQ("text", convertedStr);
798
}
799
800


802
TEST(StringViewTest, cppRuntimeExceptionOperator)
801
{
802

2
    CppRuntimeException exception = CppRuntimeException() << "test"_sv;
803



1
    ASSERT_STREQ("test", exception.what());
804
}
805
806


802
TEST(StringViewTest, literal)
807
{
808
1
    StringView str1("text");
809
1
    StringView str2 = "text"_sv;
810



1
    ASSERT_EQ(str2, str1);
811
}
812
813

2394
} // namespace zserio