Mercurial > irccd

comparison tests/src/libirccd/util/main.cpp @ 611:9fbd1700435b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: reoganize hierarchy
author David Demelier <markand@malikania.fr>
date Fri, 15 Dec 2017 15:37:58 +0100
parents tests/src/util/main.cpp@a51b5dd5b761
children 4761e7cbb6f7
comparison
equal deleted inserted replaced
610:22b3cd6f991f 611:9fbd1700435b
1 /*
2 * main.cpp -- test util functions
3 *
4 * Copyright (c) 2013-2017 David Demelier <markand@malikania.fr>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #define BOOST_TEST_MODULE "util"
20 #include <boost/test/unit_test.hpp>
21
22 #include <cstdint>
23
24 #include <irccd/util.hpp>
25 #include <irccd/fs_util.hpp>
26 #include <irccd/string_util.hpp>
27 #include <irccd/system.hpp>
28
29 namespace std {
30
31 std::ostream& operator<<(std::ostream& out, const std::vector<std::string>& list)
32 {
33 for (const auto& s : list)
34 out << s << " ";
35
36 return out;
37 }
38
39 } // !std
40
41 namespace irccd {
42
43 BOOST_AUTO_TEST_SUITE(format)
44
45 /*
46 * string_util::format function
47 * --------------------------------------------------------
48 */
49
50 BOOST_AUTO_TEST_CASE(nothing)
51 {
52 std::string expected = "hello world!";
53 std::string result = string_util::format("hello world!");
54
55 BOOST_REQUIRE_EQUAL(expected, result);
56 }
57
58 BOOST_AUTO_TEST_CASE(escape)
59 {
60 string_util::subst params;
61
62 params.keywords.emplace("target", "hello");
63
64 BOOST_REQUIRE_EQUAL("$@#", string_util::format("$@#"));
65 BOOST_REQUIRE_EQUAL(" $ @ # ", string_util::format(" $ @ # "));
66 BOOST_REQUIRE_EQUAL("#", string_util::format("#"));
67 BOOST_REQUIRE_EQUAL(" # ", string_util::format(" # "));
68 BOOST_REQUIRE_EQUAL("#@", string_util::format("#@"));
69 BOOST_REQUIRE_EQUAL("##", string_util::format("##"));
70 BOOST_REQUIRE_EQUAL("#!", string_util::format("#!"));
71 BOOST_REQUIRE_EQUAL("#{target}", string_util::format("##{target}"));
72 BOOST_REQUIRE_EQUAL("@hello", string_util::format("@#{target}", params));
73 BOOST_REQUIRE_EQUAL("hello#", string_util::format("#{target}#", params));
74 BOOST_REQUIRE_THROW(string_util::format("#{failure"), std::exception);
75 }
76
77 BOOST_AUTO_TEST_CASE(disable_date)
78 {
79 string_util::subst params;
80
81 params.flags &= ~(string_util::subst_flags::date);
82
83 BOOST_REQUIRE_EQUAL("%H:%M", string_util::format("%H:%M", params));
84 }
85
86 BOOST_AUTO_TEST_CASE(disable_keywords)
87 {
88 string_util::subst params;
89
90 params.keywords.emplace("target", "hello");
91 params.flags &= ~(string_util::subst_flags::keywords);
92
93 BOOST_REQUIRE_EQUAL("#{target}", string_util::format("#{target}", params));
94 }
95
96 BOOST_AUTO_TEST_CASE(disable_env)
97 {
98 string_util::subst params;
99
100 params.flags &= ~(string_util::subst_flags::env);
101
102 BOOST_REQUIRE_EQUAL("${HOME}", string_util::format("${HOME}", params));
103 }
104
105 BOOST_AUTO_TEST_CASE(keyword_simple)
106 {
107 string_util::subst params;
108
109 params.keywords.insert({"target", "irccd"});
110
111 std::string expected = "hello irccd!";
112 std::string result = string_util::format("hello #{target}!", params);
113
114 BOOST_REQUIRE_EQUAL(expected, result);
115 }
116
117 BOOST_AUTO_TEST_CASE(keyword_multiple)
118 {
119 string_util::subst params;
120
121 params.keywords.insert({"target", "irccd"});
122 params.keywords.insert({"source", "nightmare"});
123
124 std::string expected = "hello irccd from nightmare!";
125 std::string result = string_util::format("hello #{target} from #{source}!", params);
126
127 BOOST_REQUIRE_EQUAL(expected, result);
128 }
129
130 BOOST_AUTO_TEST_CASE(keyword_adj_twice)
131 {
132 string_util::subst params;
133
134 params.keywords.insert({"target", "irccd"});
135
136 std::string expected = "hello irccdirccd!";
137 std::string result = string_util::format("hello #{target}#{target}!", params);
138
139 BOOST_REQUIRE_EQUAL(expected, result);
140 }
141
142 BOOST_AUTO_TEST_CASE(keyword_missing)
143 {
144 std::string expected = "hello !";
145 std::string result = string_util::format("hello #{target}!");
146
147 BOOST_REQUIRE_EQUAL(expected, result);
148 }
149
150 BOOST_AUTO_TEST_CASE(env_simple)
151 {
152 std::string home = sys::env("HOME");
153
154 if (!home.empty()) {
155 std::string expected = "my home is " + home;
156 std::string result = string_util::format("my home is ${HOME}");
157
158 BOOST_REQUIRE_EQUAL(expected, result);
159 }
160 }
161
162 BOOST_AUTO_TEST_CASE(env_missing)
163 {
164 std::string expected = "value is ";
165 std::string result = string_util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}");
166
167 BOOST_REQUIRE_EQUAL(expected, result);
168 }
169
170 BOOST_AUTO_TEST_SUITE_END()
171
172 /*
173 * string_util::split function
174 * --------------------------------------------------------
175 */
176
177 BOOST_AUTO_TEST_SUITE(split)
178
179 using list = std::vector<std::string>;
180
181 BOOST_AUTO_TEST_CASE(simple)
182 {
183 list expected { "a", "b" };
184 list result = string_util::split("a;b", ";");
185
186 BOOST_REQUIRE_EQUAL(expected, result);
187 }
188
189 BOOST_AUTO_TEST_CASE(cut)
190 {
191 list expected { "msg", "#staff", "foo bar baz" };
192 list result = string_util::split("msg;#staff;foo bar baz", ";", 3);
193
194 BOOST_REQUIRE_EQUAL(expected, result);
195 }
196
197 BOOST_AUTO_TEST_SUITE_END()
198
199 /*
200 * string_util::strip function
201 * --------------------------------------------------------
202 */
203
204 BOOST_AUTO_TEST_SUITE(strip)
205
206 BOOST_AUTO_TEST_CASE(left)
207 {
208 std::string value = " 123";
209 std::string result = string_util::strip(value);
210
211 BOOST_REQUIRE_EQUAL("123", result);
212 }
213
214 BOOST_AUTO_TEST_CASE(right)
215 {
216 std::string value = "123 ";
217 std::string result = string_util::strip(value);
218
219 BOOST_REQUIRE_EQUAL("123", result);
220 }
221
222 BOOST_AUTO_TEST_CASE(both)
223 {
224 std::string value = " 123 ";
225 std::string result = string_util::strip(value);
226
227 BOOST_REQUIRE_EQUAL("123", result);
228 }
229
230 BOOST_AUTO_TEST_CASE(none)
231 {
232 std::string value = "without";
233 std::string result = string_util::strip(value);
234
235 BOOST_REQUIRE_EQUAL("without", result);
236 }
237
238 BOOST_AUTO_TEST_CASE(betweenEmpty)
239 {
240 std::string value = "one list";
241 std::string result = string_util::strip(value);
242
243 BOOST_REQUIRE_EQUAL("one list", result);
244 }
245
246 BOOST_AUTO_TEST_CASE(betweenLeft)
247 {
248 std::string value = " space at left";
249 std::string result = string_util::strip(value);
250
251 BOOST_REQUIRE_EQUAL("space at left", result);
252 }
253
254 BOOST_AUTO_TEST_CASE(betweenRight)
255 {
256 std::string value = "space at right ";
257 std::string result = string_util::strip(value);
258
259 BOOST_REQUIRE_EQUAL("space at right", result);
260 }
261
262 BOOST_AUTO_TEST_CASE(betweenBoth)
263 {
264 std::string value = " space at both ";
265 std::string result = string_util::strip(value);
266
267 BOOST_REQUIRE_EQUAL("space at both", result);
268 }
269
270 BOOST_AUTO_TEST_CASE(empty)
271 {
272 std::string value = " ";
273 std::string result = string_util::strip(value);
274
275 BOOST_REQUIRE_EQUAL("", result);
276 }
277
278 BOOST_AUTO_TEST_SUITE_END()
279
280 /*
281 * string_util::join function
282 * --------------------------------------------------------
283 */
284
285 BOOST_AUTO_TEST_SUITE(join)
286
287 BOOST_AUTO_TEST_CASE(empty)
288 {
289 std::string expected = "";
290 std::string result = string_util::join<int>({});
291
292 BOOST_REQUIRE_EQUAL(expected, result);
293 }
294
295 BOOST_AUTO_TEST_CASE(one)
296 {
297 std::string expected = "1";
298 std::string result = string_util::join({1});
299
300 BOOST_REQUIRE_EQUAL(expected, result);
301 }
302
303 BOOST_AUTO_TEST_CASE(two)
304 {
305 std::string expected = "1:2";
306 std::string result = string_util::join({1, 2});
307
308 BOOST_REQUIRE_EQUAL(expected, result);
309 }
310
311 BOOST_AUTO_TEST_CASE(delimiterString)
312 {
313 std::string expected = "1;;2;;3";
314 std::string result = string_util::join({1, 2, 3}, ";;");
315
316 BOOST_REQUIRE_EQUAL(expected, result);
317 }
318
319 BOOST_AUTO_TEST_CASE(delimiterChar)
320 {
321 std::string expected = "1@2@3@4";
322 std::string result = string_util::join({1, 2, 3, 4}, '@');
323
324 BOOST_REQUIRE_EQUAL(expected, result);
325 }
326
327 BOOST_AUTO_TEST_SUITE_END()
328
329 /*
330 * string_util::is_identifier function
331 * --------------------------------------------------------
332 */
333
334 BOOST_AUTO_TEST_SUITE(is_identifier_valid)
335
336 BOOST_AUTO_TEST_CASE(correct)
337 {
338 BOOST_REQUIRE(string_util::is_identifier("localhost"));
339 BOOST_REQUIRE(string_util::is_identifier("localhost2"));
340 BOOST_REQUIRE(string_util::is_identifier("localhost2-4_"));
341 }
342
343 BOOST_AUTO_TEST_CASE(incorrect)
344 {
345 BOOST_REQUIRE(!string_util::is_identifier(""));
346 BOOST_REQUIRE(!string_util::is_identifier("localhost with spaces"));
347 BOOST_REQUIRE(!string_util::is_identifier("localhost*"));
348 BOOST_REQUIRE(!string_util::is_identifier("&&"));
349 BOOST_REQUIRE(!string_util::is_identifier("@'"));
350 BOOST_REQUIRE(!string_util::is_identifier("##"));
351 BOOST_REQUIRE(!string_util::is_identifier("===++"));
352 }
353
354 BOOST_AUTO_TEST_SUITE_END()
355
356 /*
357 * string_util::is_boolean function
358 * --------------------------------------------------------
359 */
360
361 BOOST_AUTO_TEST_SUITE(is_boolean)
362
363 BOOST_AUTO_TEST_CASE(correct)
364 {
365 // true
366 BOOST_REQUIRE(string_util::is_boolean("true"));
367 BOOST_REQUIRE(string_util::is_boolean("True"));
368 BOOST_REQUIRE(string_util::is_boolean("TRUE"));
369 BOOST_REQUIRE(string_util::is_boolean("TruE"));
370
371 // yes
372 BOOST_REQUIRE(string_util::is_boolean("yes"));
373 BOOST_REQUIRE(string_util::is_boolean("Yes"));
374 BOOST_REQUIRE(string_util::is_boolean("YES"));
375 BOOST_REQUIRE(string_util::is_boolean("YeS"));
376
377 // on
378 BOOST_REQUIRE(string_util::is_boolean("on"));
379 BOOST_REQUIRE(string_util::is_boolean("On"));
380 BOOST_REQUIRE(string_util::is_boolean("oN"));
381 BOOST_REQUIRE(string_util::is_boolean("ON"));
382
383 // 1
384 BOOST_REQUIRE(string_util::is_boolean("1"));
385 }
386
387 BOOST_AUTO_TEST_CASE(incorrect)
388 {
389 BOOST_REQUIRE(!string_util::is_boolean("false"));
390 BOOST_REQUIRE(!string_util::is_boolean("lol"));
391 BOOST_REQUIRE(!string_util::is_boolean(""));
392 BOOST_REQUIRE(!string_util::is_boolean("0"));
393 }
394
395 BOOST_AUTO_TEST_SUITE_END()
396
397 /*
398 * string_util::is_number function
399 * --------------------------------------------------------
400 */
401
402 BOOST_AUTO_TEST_SUITE(is_number)
403
404 BOOST_AUTO_TEST_CASE(correct)
405 {
406 BOOST_REQUIRE(string_util::is_number("123"));
407 BOOST_REQUIRE(string_util::is_number("-123"));
408 BOOST_REQUIRE(string_util::is_number("123.67"));
409 }
410
411 BOOST_AUTO_TEST_CASE(incorrect)
412 {
413 BOOST_REQUIRE(!string_util::is_number("lol"));
414 BOOST_REQUIRE(!string_util::is_number("this is not a number"));
415 }
416
417 BOOST_AUTO_TEST_SUITE_END()
418
419 /*
420 * string_util::to_int function
421 * ------------------------------------------------------------------
422 */
423
424 BOOST_AUTO_TEST_SUITE(to_int)
425
426 BOOST_AUTO_TEST_CASE(signed_to_int)
427 {
428 BOOST_TEST(string_util::to_int("10") == 10);
429 BOOST_TEST(string_util::to_int<std::int8_t>("-10") == -10);
430 BOOST_TEST(string_util::to_int<std::int8_t>("10") == 10);
431 BOOST_TEST(string_util::to_int<std::int16_t>("-1000") == -1000);
432 BOOST_TEST(string_util::to_int<std::int16_t>("1000") == 1000);
433 BOOST_TEST(string_util::to_int<std::int32_t>("-1000") == -1000);
434 BOOST_TEST(string_util::to_int<std::int32_t>("1000") == 1000);
435 }
436
437 BOOST_AUTO_TEST_CASE(signed_to_int64)
438 {
439 BOOST_TEST(string_util::to_int<std::int64_t>("-9223372036854775807") == -9223372036854775807LL);
440 BOOST_TEST(string_util::to_int<std::int64_t>("9223372036854775807") == 9223372036854775807LL);
441 }
442
443 BOOST_AUTO_TEST_CASE(unsigned_to_uint)
444 {
445 BOOST_TEST(string_util::to_uint("10") == 10U);
446 BOOST_TEST(string_util::to_uint<std::uint8_t>("10") == 10U);
447 BOOST_TEST(string_util::to_uint<std::uint16_t>("1000") == 1000U);
448 BOOST_TEST(string_util::to_uint<std::uint32_t>("1000") == 1000U);
449 }
450
451 BOOST_AUTO_TEST_CASE(unsigned_to_uint64)
452 {
453 BOOST_TEST(string_util::to_uint<std::uint64_t>("18446744073709551615") == 18446744073709551615ULL);
454 }
455
456 BOOST_AUTO_TEST_SUITE_END()
457
458 BOOST_AUTO_TEST_SUITE(errors)
459
460 BOOST_AUTO_TEST_CASE(invalid_argument)
461 {
462 BOOST_REQUIRE_THROW(string_util::to_int("plopation"), std::invalid_argument);
463 BOOST_REQUIRE_THROW(string_util::to_uint("plopation"), std::invalid_argument);
464 }
465
466 BOOST_AUTO_TEST_CASE(out_of_range)
467 {
468 BOOST_REQUIRE_THROW(string_util::to_int<std::int8_t>("1000"), std::out_of_range);
469 BOOST_REQUIRE_THROW(string_util::to_int<std::int8_t>("-1000"), std::out_of_range);
470 BOOST_REQUIRE_THROW(string_util::to_uint<std::uint8_t>("1000"), std::out_of_range);
471 BOOST_REQUIRE_THROW(string_util::to_uint<std::uint8_t>("-1000"), std::out_of_range);
472 }
473
474 BOOST_AUTO_TEST_SUITE_END()
475
476 /*
477 * fs_util::find function (name)
478 * ------------------------------------------------------------------
479 */
480
481 BOOST_AUTO_TEST_SUITE(fs_find_name)
482
483 BOOST_AUTO_TEST_CASE(not_recursive)
484 {
485 auto file1 = fs_util::find(CMAKE_SOURCE_DIR "/tests/root", "file-1.txt", false);
486 auto file2 = fs_util::find(CMAKE_SOURCE_DIR "/tests/root", "file-2.txt", false);
487
488 BOOST_TEST(file1.find("file-1.txt") != std::string::npos);
489 BOOST_TEST(file2.empty());
490 }
491
492 BOOST_AUTO_TEST_CASE(recursive)
493 {
494 auto file1 = fs_util::find(CMAKE_SOURCE_DIR "/tests/root", "file-1.txt", true);
495 auto file2 = fs_util::find(CMAKE_SOURCE_DIR "/tests/root", "file-2.txt", true);
496
497 BOOST_TEST(file1.find("file-1.txt") != std::string::npos);
498 BOOST_TEST(file2.find("file-2.txt") != std::string::npos);
499 }
500
501 BOOST_AUTO_TEST_SUITE_END()
502
503 /*
504 * fs_util::find function (regex)
505 * ------------------------------------------------------------------
506 */
507
508 BOOST_AUTO_TEST_SUITE(fs_find_regex)
509
510 BOOST_AUTO_TEST_CASE(not_recursive)
511 {
512 const std::regex regex("file-[12]\\.txt");
513
514 auto file = fs_util::find(CMAKE_SOURCE_DIR "/tests/root", regex, false);
515
516 BOOST_TEST(file.find("file-1.txt") != std::string::npos);
517 }
518
519 BOOST_AUTO_TEST_CASE(recursive)
520 {
521 const std::regex regex("file-[12]\\.txt");
522
523 auto file = fs_util::find(CMAKE_SOURCE_DIR "/tests/root/level-1", regex, true);
524
525 BOOST_TEST(file.find("file-2.txt") != std::string::npos);
526 }
527
528 BOOST_AUTO_TEST_SUITE_END()
529
530 } // !irccd