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 // IntWrapper-derived types (Id16/Id32/Id64) must resolve to this overload rather than the
58 // generic stringstream-based template, including at magnitudes that exceed the 15-character
59 // small-string-optimisation threshold in libstdc++ (e.g. epoch-microsecond serial ids).
60 BOOST_CHECK_EQUAL(to_string(Id64{123456789}), "123456789"s);
61 BOOST_CHECK_EQUAL(to_string(Id64{-123456789}), "-123456789"s);
62 BOOST_CHECK_EQUAL(to_string(Id64{1783894459839125}), "1783894459839125"s);
63}
64
65BOOST_AUTO_TEST_CASE(LtrimCopyCase)
66{
67 BOOST_CHECK_EQUAL(ltrim_copy(""sv), ""sv);
68 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\r"sv), ""sv);
69 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\rfoo "sv), "foo "sv);
70 BOOST_CHECK_EQUAL(ltrim_copy("foo"sv), "foo"sv);
71
72 BOOST_CHECK_EQUAL(ltrim_copy(""s), ""s);
73 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\r"s), ""s);
74 BOOST_CHECK_EQUAL(ltrim_copy(" \t\n\v\f\rfoo "s), "foo "s);
75 BOOST_CHECK_EQUAL(ltrim_copy("foo"s), "foo"s);
76}
77
78BOOST_AUTO_TEST_CASE(RtrimCopyCase)
79{
80 BOOST_CHECK_EQUAL(rtrim_copy(""sv), ""sv);
81 BOOST_CHECK_EQUAL(rtrim_copy(" \t\n\v\f\r"sv), ""sv);
82 BOOST_CHECK_EQUAL(rtrim_copy(" foo \t\n\v\f\r"sv), " foo"sv);
83 BOOST_CHECK_EQUAL(rtrim_copy("foo"sv), "foo"sv);
84
85 BOOST_CHECK_EQUAL(rtrim_copy(""s), ""s);
86 BOOST_CHECK_EQUAL(rtrim_copy(" \t\n\v\f\r"s), ""s);
87 BOOST_CHECK_EQUAL(rtrim_copy(" foo \t\n\v\f\r"s), " foo"s);
88 BOOST_CHECK_EQUAL(rtrim_copy("foo"s), "foo"s);
89}
90
91BOOST_AUTO_TEST_CASE(TrimCopyCase)
92{
93 BOOST_CHECK_EQUAL(trim_copy(""sv), ""sv);
94 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\r"sv), ""sv);
95 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\rfoo \t\n\v\f\r"sv), "foo"sv);
96 BOOST_CHECK_EQUAL(trim_copy("foo"sv), "foo"sv);
97
98 BOOST_CHECK_EQUAL(trim_copy(""s), ""s);
99 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\r"s), ""s);
100 BOOST_CHECK_EQUAL(trim_copy(" \t\n\v\f\rfoo \t\n\v\f\r"s), "foo"s);
101 BOOST_CHECK_EQUAL(trim_copy("foo"s), "foo"s);
102}
103
104BOOST_AUTO_TEST_CASE(SplitPairCase)
105{
106 BOOST_CHECK_EQUAL(split_pair(""sv, '='), make_pair(""sv, ""sv));
107 BOOST_CHECK_EQUAL(split_pair("="sv, '='), make_pair(""sv, ""sv));
108 BOOST_CHECK_EQUAL(split_pair("a"sv, '='), make_pair("a"sv, ""sv));
109 BOOST_CHECK_EQUAL(split_pair("a="sv, '='), make_pair("a"sv, ""sv));
110 BOOST_CHECK_EQUAL(split_pair("=b"sv, '='), make_pair(""sv, "b"sv));
111 BOOST_CHECK_EQUAL(split_pair("a=b"sv, '='), make_pair("a"sv, "b"sv));
112 BOOST_CHECK_EQUAL(split_pair("a:b"sv, ':'), make_pair("a"sv, "b"sv));
113 BOOST_CHECK_EQUAL(split_pair(" a = b "sv, '='), make_pair(" a "sv, " b "sv));
114
115 BOOST_CHECK_EQUAL(split_pair(""s, '='), make_pair(""s, ""s));
116 BOOST_CHECK_EQUAL(split_pair("="s, '='), make_pair(""s, ""s));
117 BOOST_CHECK_EQUAL(split_pair("a"s, '='), make_pair("a"s, ""s));
118 BOOST_CHECK_EQUAL(split_pair("a="s, '='), make_pair("a"s, ""s));
119 BOOST_CHECK_EQUAL(split_pair("=b"s, '='), make_pair(""s, "b"s));
120 BOOST_CHECK_EQUAL(split_pair("a=b"s, '='), make_pair("a"s, "b"s));
121 BOOST_CHECK_EQUAL(split_pair("a:b"s, ':'), make_pair("a"s, "b"s));
122 BOOST_CHECK_EQUAL(split_pair(" a = b "s, '='), make_pair(" a "s, " b "s));
123}
124
125BOOST_AUTO_TEST_CASE(for_each_csv_item_tests)
126{
127 std::vector<std::string> values;
128 auto f{[&values](std::string_view value) { values.emplace_back(value); }};
129 {
130 values.clear();
131 auto csv{""sv};
132 for_each_csv_item(csv, f);
133 BOOST_REQUIRE_EQUAL(values.size(), 1UL);
134 BOOST_CHECK_EQUAL(values[0], "");
135 }
136 {
137 values.clear();
138 auto csv{","sv};
139 for_each_csv_item(csv, f);
140 BOOST_REQUIRE_EQUAL(values.size(), 2UL);
141 BOOST_CHECK_EQUAL(values[0], "");
142 BOOST_CHECK_EQUAL(values[1], "");
143 }
144 {
145 values.clear();
146 auto csv{",,"sv};
147 for_each_csv_item(csv, f);
148 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
149 BOOST_CHECK_EQUAL(values[0], "");
150 BOOST_CHECK_EQUAL(values[1], "");
151 BOOST_CHECK_EQUAL(values[2], "");
152 }
153 {
154 values.clear();
155 auto csv{"steve,,"sv};
156 for_each_csv_item(csv, f);
157 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
158 BOOST_CHECK_EQUAL(values[0], "steve");
159 BOOST_CHECK_EQUAL(values[1], "");
160 BOOST_CHECK_EQUAL(values[2], "");
161 }
162 {
163 values.clear();
164 auto csv{",steve,"sv};
165 for_each_csv_item(csv, f);
166 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
167 BOOST_CHECK_EQUAL(values[0], "");
168 BOOST_CHECK_EQUAL(values[1], "steve");
169 BOOST_CHECK_EQUAL(values[2], "");
170 }
171 {
172 values.clear();
173 auto csv{",,steve"sv};
174 for_each_csv_item(csv, f);
175 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
176 BOOST_CHECK_EQUAL(values[0], "");
177 BOOST_CHECK_EQUAL(values[1], "");
178 BOOST_CHECK_EQUAL(values[2], "steve");
179 }
180 {
181 values.clear();
182 auto csv{"steve,woz,'ere"sv};
183 for_each_csv_item(csv, f);
184 BOOST_REQUIRE_EQUAL(values.size(), 3UL);
185 BOOST_CHECK_EQUAL(values[0], "steve");
186 BOOST_CHECK_EQUAL(values[1], "woz");
187 BOOST_CHECK_EQUAL(values[2], "'ere");
188 }
189}
190
191BOOST_AUTO_TEST_CASE(PstrlenCase)
192{
193 constexpr char ZeroPad[] = "foo";
194 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad, ~0), 3UL);
195 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad, 2), 2UL);
196 BOOST_CHECK_EQUAL(pstrlen<'\0'>(ZeroPad), 3UL);
197
198 constexpr char SpacePad[] = "foo ";
199 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad, ~0), 3UL);
200 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad, 2), 2UL);
201 BOOST_CHECK_EQUAL(pstrlen<' '>(SpacePad), 3UL);
202}
203
204BOOST_AUTO_TEST_CASE(PstrcpyCase)
205{
206 struct TOOLBOX_PACKED {
207 char data[8];
208 char canary;
209 } buf{};
210
211 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
212
213 clear();
214 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
215 BOOST_CHECK_EQUAL(buf.canary, '#');
216
217 // Zero / C-String / Explicit Length.
218 clear();
219 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar", sizeof(buf.data)), 6UL);
220 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
221 BOOST_CHECK_EQUAL(buf.canary, '#');
222
223 clear();
224 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
225 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
226 BOOST_CHECK_EQUAL(buf.canary, '#');
227
228 // Zero / C-String / Implied Length.
229 clear();
230 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"), 6UL);
231 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
232 BOOST_CHECK_EQUAL(buf.canary, '#');
233
234 clear();
235 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"), 8UL);
236 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
237 BOOST_CHECK_EQUAL(buf.canary, '#');
238
239 // Zero / String View / Explicit Length.
240 clear();
241 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
242 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
243 BOOST_CHECK_EQUAL(buf.canary, '#');
244
245 clear();
246 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
247 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
248 BOOST_CHECK_EQUAL(buf.canary, '#');
249
250 // Zero / String View / Implied Length.
251 clear();
252 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobar"sv), 6UL);
253 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar\0\0", sizeof(buf.data)), 0);
254 BOOST_CHECK_EQUAL(buf.canary, '#');
255
256 clear();
257 BOOST_CHECK_EQUAL(pstrcpy<'\0'>(buf.data, "foobarbaz"sv), 8UL);
258 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
259 BOOST_CHECK_EQUAL(buf.canary, '#');
260
261 // Space / C-String / Explicit Length.
262 clear();
263 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar", sizeof(buf.data)), 6UL);
264 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
265 BOOST_CHECK_EQUAL(buf.canary, '#');
266
267 clear();
268 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
269 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
270 BOOST_CHECK_EQUAL(buf.canary, '#');
271
272 // Space / C-String / Implied Length.
273 clear();
274 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"), 6UL);
275 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
276 BOOST_CHECK_EQUAL(buf.canary, '#');
277
278 clear();
279 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"), 8UL);
280 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
281 BOOST_CHECK_EQUAL(buf.canary, '#');
282
283 // Space / String View / Explicit Length.
284 clear();
285 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
286 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
287 BOOST_CHECK_EQUAL(buf.canary, '#');
288
289 clear();
290 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
291 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
292 BOOST_CHECK_EQUAL(buf.canary, '#');
293
294 // Space / String View / Implied Length.
295 clear();
296 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobar"sv), 6UL);
297 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobar ", sizeof(buf.data)), 0);
298 BOOST_CHECK_EQUAL(buf.canary, '#');
299
300 clear();
301 BOOST_CHECK_EQUAL(pstrcpy<' '>(buf.data, "foobarbaz"sv), 8UL);
302 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
303 BOOST_CHECK_EQUAL(buf.canary, '#');
304}
305
306BOOST_AUTO_TEST_CASE(PstrcpyidCase)
307{
308 struct TOOLBOX_PACKED {
309 char data[8];
310 char canary;
311 } buf{};
312
313 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
314
315 clear();
316 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
317 BOOST_CHECK_EQUAL(buf.canary, '#');
318
319 // Zero / Explicit Length.
320 clear();
321 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456, sizeof(buf.data)), 6UL);
322 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456\0\0", sizeof(buf.data)), 0);
323 BOOST_CHECK_EQUAL(buf.canary, '#');
324
325 clear();
326 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, -1234567, sizeof(buf.data)), 8UL);
327 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
328 BOOST_CHECK_EQUAL(buf.canary, '#');
329
330 clear();
331 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456789, sizeof(buf.data)), 0UL);
332 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
333 BOOST_CHECK_EQUAL(buf.canary, '#');
334
335 // Space / Explicit Length.
336 clear();
337 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456, sizeof(buf.data)), 6UL);
338 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456 ", sizeof(buf.data)), 0);
339 BOOST_CHECK_EQUAL(buf.canary, '#');
340
341 clear();
342 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, -1234567, sizeof(buf.data)), 8UL);
343 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
344 BOOST_CHECK_EQUAL(buf.canary, '#');
345
346 clear();
347 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456789, sizeof(buf.data)), 0UL);
348 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
349 BOOST_CHECK_EQUAL(buf.canary, '#');
350
351 // Zero / Implied Length.
352 clear();
353 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456), 6UL);
354 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456\0\0", sizeof(buf.data)), 0);
355 BOOST_CHECK_EQUAL(buf.canary, '#');
356
357 clear();
358 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, -1234567), 8UL);
359 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
360 BOOST_CHECK_EQUAL(buf.canary, '#');
361
362 clear();
363 BOOST_CHECK_EQUAL(pstrcpyid<'\0'>(buf.data, 123456789), 0UL);
364 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
365 BOOST_CHECK_EQUAL(buf.canary, '#');
366
367 // Space / Implied Length.
368 clear();
369 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456), 6UL);
370 BOOST_CHECK_EQUAL(memcmp(buf.data, "123456 ", sizeof(buf.data)), 0);
371 BOOST_CHECK_EQUAL(buf.canary, '#');
372
373 clear();
374 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, -1234567), 8UL);
375 BOOST_CHECK_EQUAL(memcmp(buf.data, "-1234567", sizeof(buf.data)), 0);
376 BOOST_CHECK_EQUAL(buf.canary, '#');
377
378 clear();
379 BOOST_CHECK_EQUAL(pstrcpyid<' '>(buf.data, 123456789), 0UL);
380 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
381 BOOST_CHECK_EQUAL(buf.canary, '#');
382}
383
384BOOST_AUTO_TEST_CASE(LpstrlenCase)
385{
386 constexpr char ZeroPad[4] = {'\0', 'f', 'o', 'o'};
387 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad, sizeof(ZeroPad)), 3UL);
388 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad, 3), 2UL);
389 BOOST_CHECK_EQUAL(lpstrlen<'\0'>(ZeroPad), 3UL);
390
391 constexpr char SpacePad[4] = {' ', 'f', 'o', 'o'};
392 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad, sizeof(ZeroPad)), 3UL);
393 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad, 3), 2UL);
394 BOOST_CHECK_EQUAL(lpstrlen<' '>(SpacePad), 3UL);
395}
396
397BOOST_AUTO_TEST_CASE(LpstrcpyCase)
398{
399 struct TOOLBOX_PACKED {
400 char data[8];
401 char canary;
402 } buf{};
403
404 auto clear = [&]() { memset(buf.data, '#', sizeof(buf.data) + 1); };
405
406 clear();
407 BOOST_CHECK_EQUAL(memcmp(buf.data, "########", sizeof(buf.data)), 0);
408 BOOST_CHECK_EQUAL(buf.canary, '#');
409
410 // Zero / C-String / Explicit Length.
411 clear();
412 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar", sizeof(buf.data)), 6UL);
413 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
414 BOOST_CHECK_EQUAL(buf.canary, '#');
415
416 clear();
417 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
418 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
419 BOOST_CHECK_EQUAL(buf.canary, '#');
420
421 // Zero / C-String / Implied Length.
422 clear();
423 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"), 6UL);
424 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
425 BOOST_CHECK_EQUAL(buf.canary, '#');
426
427 clear();
428 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"), 8UL);
429 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
430 BOOST_CHECK_EQUAL(buf.canary, '#');
431
432 // Zero / String View / Explicit Length.
433 clear();
434 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
435 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
436 BOOST_CHECK_EQUAL(buf.canary, '#');
437
438 clear();
439 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
440 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
441 BOOST_CHECK_EQUAL(buf.canary, '#');
442
443 // Zero / String View / Implied Length.
444 clear();
445 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobar"sv), 6UL);
446 BOOST_CHECK_EQUAL(memcmp(buf.data, "\0\0foobar", sizeof(buf.data)), 0);
447 BOOST_CHECK_EQUAL(buf.canary, '#');
448
449 clear();
450 BOOST_CHECK_EQUAL(lpstrcpy<'\0'>(buf.data, "foobarbaz"sv), 8UL);
451 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
452 BOOST_CHECK_EQUAL(buf.canary, '#');
453
454 // Space / C-String / Explicit Length.
455 clear();
456 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar", sizeof(buf.data)), 6UL);
457 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
458 BOOST_CHECK_EQUAL(buf.canary, '#');
459
460 clear();
461 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz", sizeof(buf.data)), 8UL);
462 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
463 BOOST_CHECK_EQUAL(buf.canary, '#');
464
465 // Space / C-String / Implied Length.
466 clear();
467 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"), 6UL);
468 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
469 BOOST_CHECK_EQUAL(buf.canary, '#');
470
471 clear();
472 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"), 8UL);
473 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
474 BOOST_CHECK_EQUAL(buf.canary, '#');
475
476 // Space / String View / Explicit Length.
477 clear();
478 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"sv, sizeof(buf.data)), 6UL);
479 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
480 BOOST_CHECK_EQUAL(buf.canary, '#');
481
482 clear();
483 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"sv, sizeof(buf.data)), 8UL);
484 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
485 BOOST_CHECK_EQUAL(buf.canary, '#');
486
487 // Space / String View / Implied Length.
488 clear();
489 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobar"sv), 6UL);
490 BOOST_CHECK_EQUAL(memcmp(buf.data, " foobar", sizeof(buf.data)), 0);
491 BOOST_CHECK_EQUAL(buf.canary, '#');
492
493 clear();
494 BOOST_CHECK_EQUAL(lpstrcpy<' '>(buf.data, "foobarbaz"sv), 8UL);
495 BOOST_CHECK_EQUAL(memcmp(buf.data, "foobarba", sizeof(buf.data)), 0);
496 BOOST_CHECK_EQUAL(buf.canary, '#');
497}
498
499BOOST_AUTO_TEST_CASE(MakeStringCase)
500{
501 auto res = make_string(1, 1.2, "foo");
502 BOOST_CHECK_EQUAL(res, "11.2foo");
503}
504
505BOOST_AUTO_TEST_CASE(FromString)
506{
507 BOOST_CHECK_EQUAL(from_string<int>("42"), 42);
508 BOOST_CHECK_EQUAL(from_string<std::string>("42"), "42");
509 BOOST_CHECK_EQUAL(from_string<std::string>("42"sv), "42");
510 BOOST_CHECK_EQUAL(from_string<std::filesystem::path>("/toolbox"),
511 std::filesystem::path("/toolbox"));
512 BOOST_CHECK(from_string<std::filesystem::path>("/toolbox"sv)
513 == std::filesystem::path("/toolbox"));
514}
515
516BOOST_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:56
toolbox::sys::clear
void clear(timeval &tv) noexcept
Definition Time.hpp:304
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:56
toolbox::util::lpstrlen
constexpr std::size_t lpstrlen(const char *src, std::size_t n) noexcept
Definition String.hpp:305
toolbox::util::make_string
std::string make_string(ArgsT &&... args)
Definition String.hpp:388
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:155
toolbox::util::ltrim_copy
std::string_view ltrim_copy(std::string_view s) noexcept
Definition String.hpp:107
toolbox::util::rtrim_copy
std::string_view rtrim_copy(std::string_view s) noexcept
Definition String.hpp:119
toolbox::util::pstrlen
constexpr std::size_t pstrlen(const char *src, std::size_t n) noexcept
Definition String.hpp:180
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:131
toolbox::util::pstrcpy
constexpr std::size_t pstrcpy(char *dst, const char *src, std::size_t n) noexcept
Definition String.hpp:212
toolbox::util::pstrcpyid
constexpr std::size_t pstrcpyid(char *dst, std::int64_t id, std::size_t n) noexcept
Definition String.hpp:280
toolbox::util::lpstrcpy
constexpr std::size_t lpstrcpy(char *dst, const char *src, std::size_t n) noexcept
Definition String.hpp:332
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