Toolbox snapshot
The Reactive C++ Toolbox
Loading...
Searching...
No Matches
String.ut.cpp
Go to the documentation of this file.
1// The Reactive C++ Toolbox.
2// Copyright (C) 2013-2019 Swirly Cloud Limited
3// Copyright (C) 2023 Reactive Markets Limited
4//
5// Licensed under the Apache License, Version 2.0 (the "License");
6// you may not use this file except in compliance with the License.
7// You may obtain a copy of the License at
8//
9// http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing, software
12// distributed under the License is distributed on an "AS IS" BASIS,
13// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14// See the License for the specific language governing permissions and
15// limitations under the License.
16
17#include "String.hpp"
18
19#include <boost/test/unit_test.hpp>
20
21#include <filesystem>
22
23namespace std {
24template <typename T, typename U>
25ostream& operator<<(ostream& os, const pair<T, U>& p)
26{
27 return os << '(' << p.first << ',' << p.second << ')';
28}
29} // namespace std
30
31using namespace std;
32using namespace toolbox;
33
34BOOST_AUTO_TEST_SUITE(StringSuite)
35
36BOOST_AUTO_TEST_CASE(StringViewCase)
37{
38 // Make sure the string is not optimised away.
39 const auto s = to_string(time(nullptr));
40
41 // Ensure that std::string_view iterators are equivalent across copies of the std::string_view.
42 const string_view a{s};
43 const string_view b{a};
44
45 // Best effort to detect broken assumption.
46 const void* aptr = a.data();
47 const void* bptr = b.data();
48 BOOST_CHECK_EQUAL(aptr, bptr);
49}
50
51BOOST_AUTO_TEST_CASE(ToStringCase)
52{
53 BOOST_CHECK_EQUAL(to_string("foo"sv), "foo"s);
54 BOOST_CHECK_EQUAL(stoi(to_string(12345)), 12345);
55 BOOST_CHECK_EQUAL(stod(to_string(12345.67)), 12345.67);
56}
57
58BOOST_AUTO_TEST_CASE(LtrimCopyCase)
59{
60 BOOST_CHECK_EQUAL(ltrim_copy(""sv), ""sv);
61 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\r"sv), ""sv);
62 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\rfoo "sv), "foo "sv);
63 BOOST_CHECK_EQUAL(ltrim_copy("foo"sv), "foo"sv);
64
65 BOOST_CHECK_EQUAL(ltrim_copy(""s), ""s);
66 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\r"s), ""s);
67 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\rfoo "s), "foo "s);
68 BOOST_CHECK_EQUAL(ltrim_copy("foo"s), "foo"s);
69}
70
71BOOST_AUTO_TEST_CASE(RtrimCopyCase)
72{
73 BOOST_CHECK_EQUAL(rtrim_copy(""sv), ""sv);
74 BOOST_CHECK_EQUAL(rtrim_copy(" \t\n\v\f\r"sv), ""sv);
75 BOOST_CHECK_EQUAL(rtrim_copy(" foo \t\n\v\f\r"sv), " foo"sv);
76 BOOST_CHECK_EQUAL(rtrim_copy("foo"sv), "foo"sv);
77
78 BOOST_CHECK_EQUAL(rtrim_copy(""s), ""s);
79 BOOST_CHECK_EQUAL(rtrim_copy(" \t\n\v\f\r"s), ""s);
80 BOOST_CHECK_EQUAL(rtrim_copy(" foo \t\n\v\f\r"s), " foo"s);
81 BOOST_CHECK_EQUAL(rtrim_copy("foo"s), "foo"s);
82}
83
84BOOST_AUTO_TEST_CASE(TrimCopyCase)
85{
86 BOOST_CHECK_EQUAL(trim_copy(""sv), ""sv);
87 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\r"sv), ""sv);
88 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\rfoo \t\n\v\f\r"sv), "foo"sv);
89 BOOST_CHECK_EQUAL(trim_copy("foo"sv), "foo"sv);
90
91 BOOST_CHECK_EQUAL(trim_copy(""s), ""s);
92 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\r"s), ""s);
93 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\rfoo \t\n\v\f\r"s), "foo"s);
94 BOOST_CHECK_EQUAL(trim_copy("foo"s), "foo"s);
95}
96
97BOOST_AUTO_TEST_CASE(SplitPairCase)
98{
99 BOOST_CHECK_EQUAL(split_pair(""sv, '='), make_pair(""sv, ""sv));
100 BOOST_CHECK_EQUAL(split_pair("="sv, '='), make_pair(""sv, ""sv));
101 BOOST_CHECK_EQUAL(split_pair("a"sv, '='), make_pair("a"sv, ""sv));
102 BOOST_CHECK_EQUAL(split_pair("a="sv, '='), make_pair("a"sv, ""sv));
103 BOOST_CHECK_EQUAL(split_pair("=b"sv, '='), make_pair(""sv, "b"sv));
104 BOOST_CHECK_EQUAL(split_pair("a=b"sv, '='), make_pair("a"sv, "b"sv));
105 BOOST_CHECK_EQUAL(split_pair("a:b"sv, ':'), make_pair("a"sv, "b"sv));
106 BOOST_CHECK_EQUAL(split_pair(" a = b "sv, '='), make_pair(" a "sv, " b "sv));
107
108 BOOST_CHECK_EQUAL(split_pair(""s, '='), make_pair(""s, ""s));
109 BOOST_CHECK_EQUAL(split_pair("="s, '='), make_pair(""s, ""s));
110 BOOST_CHECK_EQUAL(split_pair("a"s, '='), make_pair("a"s, ""s));
111 BOOST_CHECK_EQUAL(split_pair("a="s, '='), make_pair("a"s, ""s));
112 BOOST_CHECK_EQUAL(split_pair("=b"s, '='), make_pair(""s, "b"s));
113 BOOST_CHECK_EQUAL(split_pair("a=b"s, '='), make_pair("a"s, "b"s));
114 BOOST_CHECK_EQUAL(split_pair("a:b"s, ':'), make_pair("a"s, "b"s));
115 BOOST_CHECK_EQUAL(split_pair(" a = b "s, '='), make_pair(" a "s, " b "s));
116}
117
118BOOST_AUTO_TEST_CASE(for_each_csv_item_tests)
119{
120 std::vector<std::string> values;
121 auto f{[&values](std::string_view value) { values.emplace_back(value); }};
122 {
123 values.clear();
124 auto csv{""sv};
125 for_each_csv_item(csv, f);
126 BOOST_REQUIRE_EQUAL(values.size(), 1UL);
127 BOOST_CHECK_EQUAL(values[0], "");
128 }
129 {
130 values.clear();
131 auto csv{","sv};
132 for_each_csv_item(csv, f);
133 BOOST_REQUIRE_EQUAL(values.size(), 2UL);
134 BOOST_CHECK_EQUAL(values[0], "");
135 BOOST_CHECK_EQUAL(values[1], "");
136 }
137 {
138 values.clear();
139 auto csv{",,"sv};
140 for_each_csv_item(csv, f);
141 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
142 BOOST_CHECK_EQUAL(values[0], "");
143 BOOST_CHECK_EQUAL(values[1], "");
144 BOOST_CHECK_EQUAL(values[2], "");
145 }
146 {
147 values.clear();
148 auto csv{"steve,,"sv};
149 for_each_csv_item(csv, f);
150 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
151 BOOST_CHECK_EQUAL(values[0], "steve");
152 BOOST_CHECK_EQUAL(values[1], "");
153 BOOST_CHECK_EQUAL(values[2], "");
154 }
155 {
156 values.clear();
157 auto csv{",steve,"sv};
158 for_each_csv_item(csv, f);
159 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
160 BOOST_CHECK_EQUAL(values[0], "");
161 BOOST_CHECK_EQUAL(values[1], "steve");
162 BOOST_CHECK_EQUAL(values[2], "");
163 }
164 {
165 values.clear();
166 auto csv{",,steve"sv};
167 for_each_csv_item(csv, f);
168 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
169 BOOST_CHECK_EQUAL(values[0], "");
170 BOOST_CHECK_EQUAL(values[1], "");
171 BOOST_CHECK_EQUAL(values[2], "steve");
172 }
173 {
174 values.clear();
175 auto csv{"steve,woz,'ere"sv};
176 for_each_csv_item(csv, f);
177 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
178 BOOST_CHECK_EQUAL(values[0], "steve");
179 BOOST_CHECK_EQUAL(values[1], "woz");
180 BOOST_CHECK_EQUAL(values[2], "'ere");
181 }
182}
183
184BOOST_AUTO_TEST_CASE(PstrlenCase)
185{
186 constexpr char ZeroPad[] = "foo";
187 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad, ~0), 3UL);
188 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad, 2), 2UL);
189 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad), 3UL);
190
191 constexpr char SpacePad[] = "foo ";
192 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad, ~0), 3UL);
193 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad, 2), 2UL);
194 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad), 3UL);
195}
196
197BOOST_AUTO_TEST_CASE(PstrcpyCase)
198{
199 struct TOOLBOX_PACKED {
200 char data[8];
201 char canary;
202 } buf{};
203
204 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
205
206 clear();
207 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
208 BOOST_CHECK_EQUAL(buf.canary, '#');
209
210 // Zero / C-String / Explicit Length.
211 clear();
212 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar", sizeof(buf.data)), 6UL);
213 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
214 BOOST_CHECK_EQUAL(buf.canary, '#');
215
216 clear();
217 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
218 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
219 BOOST_CHECK_EQUAL(buf.canary, '#');
220
221 // Zero / C-String / Implied Length.
222 clear();
223 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"), 6UL);
224 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
225 BOOST_CHECK_EQUAL(buf.canary, '#');
226
227 clear();
228 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"), 8UL);
229 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
230 BOOST_CHECK_EQUAL(buf.canary, '#');
231
232 // Zero / String View / Explicit Length.
233 clear();
234 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
235 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
236 BOOST_CHECK_EQUAL(buf.canary, '#');
237
238 clear();
239 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
240 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
241 BOOST_CHECK_EQUAL(buf.canary, '#');
242
243 // Zero / String View / Implied Length.
244 clear();
245 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"sv), 6UL);
246 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
247 BOOST_CHECK_EQUAL(buf.canary, '#');
248
249 clear();
250 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"sv), 8UL);
251 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
252 BOOST_CHECK_EQUAL(buf.canary, '#');
253
254 // Space / C-String / Explicit Length.
255 clear();
256 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar", sizeof(buf.data)), 6UL);
257 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
258 BOOST_CHECK_EQUAL(buf.canary, '#');
259
260 clear();
261 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
262 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
263 BOOST_CHECK_EQUAL(buf.canary, '#');
264
265 // Space / C-String / Implied Length.
266 clear();
267 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"), 6UL);
268 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
269 BOOST_CHECK_EQUAL(buf.canary, '#');
270
271 clear();
272 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"), 8UL);
273 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
274 BOOST_CHECK_EQUAL(buf.canary, '#');
275
276 // Space / String View / Explicit Length.
277 clear();
278 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
279 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
280 BOOST_CHECK_EQUAL(buf.canary, '#');
281
282 clear();
283 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
284 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
285 BOOST_CHECK_EQUAL(buf.canary, '#');
286
287 // Space / String View / Implied Length.
288 clear();
289 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"sv), 6UL);
290 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
291 BOOST_CHECK_EQUAL(buf.canary, '#');
292
293 clear();
294 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"sv), 8UL);
295 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
296 BOOST_CHECK_EQUAL(buf.canary, '#');
297}
298
299BOOST_AUTO_TEST_CASE(PstrcpyidCase)
300{
301 struct TOOLBOX_PACKED {
302 char data[8];
303 char canary;
304 } buf{};
305
306 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
307
308 clear();
309 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
310 BOOST_CHECK_EQUAL(buf.canary, '#');
311
312 // Zero / Explicit Length.
313 clear();
314 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456, sizeof(buf.data)), 6UL);
315 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456\0\0", sizeof(buf.data)), 0);
316 BOOST_CHECK_EQUAL(buf.canary, '#');
317
318 clear();
319 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, -1234567, sizeof(buf.data)), 8UL);
320 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
321 BOOST_CHECK_EQUAL(buf.canary, '#');
322
323 clear();
324 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456789, sizeof(buf.data)), 0UL);
325 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
326 BOOST_CHECK_EQUAL(buf.canary, '#');
327
328 // Space / Explicit Length.
329 clear();
330 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456, sizeof(buf.data)), 6UL);
331 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456 ", sizeof(buf.data)), 0);
332 BOOST_CHECK_EQUAL(buf.canary, '#');
333
334 clear();
335 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, -1234567, sizeof(buf.data)), 8UL);
336 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
337 BOOST_CHECK_EQUAL(buf.canary, '#');
338
339 clear();
340 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456789, sizeof(buf.data)), 0UL);
341 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
342 BOOST_CHECK_EQUAL(buf.canary, '#');
343
344 // Zero / Implied Length.
345 clear();
346 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456), 6UL);
347 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456\0\0", sizeof(buf.data)), 0);
348 BOOST_CHECK_EQUAL(buf.canary, '#');
349
350 clear();
351 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, -1234567), 8UL);
352 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
353 BOOST_CHECK_EQUAL(buf.canary, '#');
354
355 clear();
356 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456789), 0UL);
357 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
358 BOOST_CHECK_EQUAL(buf.canary, '#');
359
360 // Space / Implied Length.
361 clear();
362 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456), 6UL);
363 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456 ", sizeof(buf.data)), 0);
364 BOOST_CHECK_EQUAL(buf.canary, '#');
365
366 clear();
367 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, -1234567), 8UL);
368 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
369 BOOST_CHECK_EQUAL(buf.canary, '#');
370
371 clear();
372 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456789), 0UL);
373 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
374 BOOST_CHECK_EQUAL(buf.canary, '#');
375}
376
377BOOST_AUTO_TEST_CASE(LpstrlenCase)
378{
379 constexpr char ZeroPad[4] = {'\0', 'f', 'o', 'o'};
380 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad, sizeof(ZeroPad)), 3UL);
381 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad, 3), 2UL);
382 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad), 3UL);
383
384 constexpr char SpacePad[4] = {' ', 'f', 'o', 'o'};
385 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad, sizeof(ZeroPad)), 3UL);
386 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad, 3), 2UL);
387 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad), 3UL);
388}
389
390BOOST_AUTO_TEST_CASE(LpstrcpyCase)
391{
392 struct TOOLBOX_PACKED {
393 char data[8];
394 char canary;
395 } buf{};
396
397 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
398
399 clear();
400 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
401 BOOST_CHECK_EQUAL(buf.canary, '#');
402
403 // Zero / C-String / Explicit Length.
404 clear();
405 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar", sizeof(buf.data)), 6UL);
406 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
407 BOOST_CHECK_EQUAL(buf.canary, '#');
408
409 clear();
410 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
411 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
412 BOOST_CHECK_EQUAL(buf.canary, '#');
413
414 // Zero / C-String / Implied Length.
415 clear();
416 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"), 6UL);
417 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
418 BOOST_CHECK_EQUAL(buf.canary, '#');
419
420 clear();
421 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"), 8UL);
422 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
423 BOOST_CHECK_EQUAL(buf.canary, '#');
424
425 // Zero / String View / Explicit Length.
426 clear();
427 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
428 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
429 BOOST_CHECK_EQUAL(buf.canary, '#');
430
431 clear();
432 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
433 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
434 BOOST_CHECK_EQUAL(buf.canary, '#');
435
436 // Zero / String View / Implied Length.
437 clear();
438 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"sv), 6UL);
439 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
440 BOOST_CHECK_EQUAL(buf.canary, '#');
441
442 clear();
443 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"sv), 8UL);
444 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
445 BOOST_CHECK_EQUAL(buf.canary, '#');
446
447 // Space / C-String / Explicit Length.
448 clear();
449 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar", sizeof(buf.data)), 6UL);
450 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
451 BOOST_CHECK_EQUAL(buf.canary, '#');
452
453 clear();
454 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
455 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
456 BOOST_CHECK_EQUAL(buf.canary, '#');
457
458 // Space / C-String / Implied Length.
459 clear();
460 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"), 6UL);
461 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
462 BOOST_CHECK_EQUAL(buf.canary, '#');
463
464 clear();
465 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"), 8UL);
466 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
467 BOOST_CHECK_EQUAL(buf.canary, '#');
468
469 // Space / String View / Explicit Length.
470 clear();
471 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
472 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
473 BOOST_CHECK_EQUAL(buf.canary, '#');
474
475 clear();
476 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
477 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
478 BOOST_CHECK_EQUAL(buf.canary, '#');
479
480 // Space / String View / Implied Length.
481 clear();
482 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"sv), 6UL);
483 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
484 BOOST_CHECK_EQUAL(buf.canary, '#');
485
486 clear();
487 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"sv), 8UL);
488 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
489 BOOST_CHECK_EQUAL(buf.canary, '#');
490}
491
492BOOST_AUTO_TEST_CASE(MakeStringCase)
493{
494 auto res = make_string(1, 1.2, "foo");
495 BOOST_CHECK_EQUAL(res, "11.2foo");
496}
497
498BOOST_AUTO_TEST_CASE(FromString)
499{
500 BOOST_CHECK_EQUAL(from_string<int>("42"), 42);
501 BOOST_CHECK_EQUAL(from_string<std::string>("42"), "42");
502 BOOST_CHECK_EQUAL(from_string<std::string>("42"sv), "42");
503 BOOST_CHECK_EQUAL(from_string<std::filesystem::path>("/toolbox"),
504 std::filesystem::path("/toolbox"));
505 BOOST_CHECK(from_string<std::filesystem::path>("/toolbox"sv)
506 == std::filesystem::path("/toolbox"));
507}
508
509BOOST_AUTO_TEST_SUITE_END()
TOOLBOX_PACKED
#define TOOLBOX_PACKED
Definition Config.h:29
BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(v.size(), 10U)
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(StringViewCase)
Definition String.ut.cpp:36
std
STL namespace.
std::operator<<
ostream & operator<<(ostream &os, const pair< T, U > &p)
Definition Parser.ut.cpp:29
toolbox::io::data
const DataT & data(const MsgEvent &ev) noexcept
Definition Event.hpp:54
toolbox::sys::clear
void clear(timeval &tv) noexcept
Definition Time.hpp:303
toolbox::util::split_pair
pair< string_view, string_view > split_pair(string_view s, string_view delim) noexcept
Definition String.cpp:52
toolbox::util::to_string
std::string to_string(ValueT &&val)
Definition String.hpp:55
toolbox::util::lpstrlen
constexpr std::size_t lpstrlen(const char *src, std::size_t n) noexcept
Definition String.hpp:295
toolbox::util::make_string
std::string make_string(ArgsT &&... args)
Definition String.hpp:378
toolbox::util::for_each_csv_item
void for_each_csv_item(std::string_view csv, F f) noexcept(noexcept(split_pair(std::declval< std::string_view >(), ',')) &&noexcept(f(std::declval< std::string_view >())))
Definition String.hpp:145
toolbox::util::ltrim_copy
std::string_view ltrim_copy(std::string_view s) noexcept
Definition String.hpp:97
toolbox::util::rtrim_copy
std::string_view rtrim_copy(std::string_view s) noexcept
Definition String.hpp:109
toolbox::util::pstrlen
constexpr std::size_t pstrlen(const char *src, std::size_t n) noexcept
Definition String.hpp:170
toolbox::util::sv
std::string_view sv
Definition Tokeniser.hpp:26
toolbox::util::trim_copy
std::string_view trim_copy(std::string_view s) noexcept
Definition String.hpp:121
toolbox::util::pstrcpy
constexpr std::size_t pstrcpy(char *dst, const char *src, std::size_t n) noexcept
Definition String.hpp:202
toolbox::util::pstrcpyid
constexpr std::size_t pstrcpyid(char *dst, std::int64_t id, std::size_t n) noexcept
Definition String.hpp:270
toolbox::util::lpstrcpy
constexpr std::size_t lpstrcpy(char *dst, const char *src, std::size_t n) noexcept
Definition String.hpp:322
toolbox::util::stod
double stod(std::string_view sv, double dfl) noexcept
Definition Utility.cpp:91
toolbox::util::bind
constexpr auto bind() noexcept
Definition Slot.hpp:97
BOOST_CHECK
BOOST_CHECK(isnan(stod(""sv, numeric_limits< double >::quiet_NaN())))
Generated by doxygen 1.9.8