Mercurial > irccd

comparison tests/util/main.cpp @ 521:e03521cf207b

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