Mercurial > irccd
comparison tests/util/main.cpp @ 521:e03521cf207b
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() |