Mercurial > irccd

comparison tests/src/libcommon/string-util/main.cpp @ 773:8c44bbcbbab9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Misc: style, cleanup and update
author David Demelier <markand@malikania.fr>
date Fri, 26 Oct 2018 13:01:00 +0200
parents 35c1517d705d
children
comparison
equal deleted inserted replaced
772:f5ccf65ae929 773:8c44bbcbbab9
32 */ 32 */
33 BOOST_AUTO_TEST_SUITE(format) 33 BOOST_AUTO_TEST_SUITE(format)
34 34
35 BOOST_AUTO_TEST_CASE(nothing) 35 BOOST_AUTO_TEST_CASE(nothing)
36 { 36 {
37 std::string expected = "hello world!"; 37 std::string expected = "hello world!";
38 std::string result = string_util::format("hello world!"); 38 std::string result = string_util::format("hello world!");
39 39
40 BOOST_TEST(expected == result); 40 BOOST_TEST(expected == result);
41 } 41 }
42 42
43 BOOST_AUTO_TEST_CASE(escape) 43 BOOST_AUTO_TEST_CASE(escape)
44 { 44 {
45 string_util::subst params; 45 string_util::subst params;
46 46
47 params.keywords.emplace("target", "hello"); 47 params.keywords.emplace("target", "hello");
48 48
49 BOOST_TEST(string_util::format("$@#") == "$@#"); 49 BOOST_TEST(string_util::format("$@#") == "$@#");
50 BOOST_TEST(string_util::format(" $ @ # ") == " $ @ # "); 50 BOOST_TEST(string_util::format(" $ @ # ") == " $ @ # ");
51 BOOST_TEST(string_util::format("#") == "#"); 51 BOOST_TEST(string_util::format("#") == "#");
52 BOOST_TEST(string_util::format(" # ") == " # "); 52 BOOST_TEST(string_util::format(" # ") == " # ");
53 BOOST_TEST(string_util::format("#@") == "#@"); 53 BOOST_TEST(string_util::format("#@") == "#@");
54 BOOST_TEST(string_util::format("##") == "##"); 54 BOOST_TEST(string_util::format("##") == "##");
55 BOOST_TEST(string_util::format("#!") == "#!"); 55 BOOST_TEST(string_util::format("#!") == "#!");
56 BOOST_TEST(string_util::format("##{target}") == "#{target}"); 56 BOOST_TEST(string_util::format("##{target}") == "#{target}");
57 BOOST_TEST(string_util::format("@#{target}", params) == "@hello"); 57 BOOST_TEST(string_util::format("@#{target}", params) == "@hello");
58 BOOST_TEST(string_util::format("#{target}#", params) == "hello#"); 58 BOOST_TEST(string_util::format("#{target}#", params) == "hello#");
59 BOOST_REQUIRE_THROW(string_util::format("#{failure"), std::exception); 59 BOOST_REQUIRE_THROW(string_util::format("#{failure"), std::exception);
60 } 60 }
61 61
62 BOOST_AUTO_TEST_CASE(disable_date) 62 BOOST_AUTO_TEST_CASE(disable_date)
63 { 63 {
64 string_util::subst params; 64 string_util::subst params;
65 65
66 params.flags &= ~(string_util::subst_flags::date); 66 params.flags &= ~(string_util::subst_flags::date);
67 67
68 BOOST_TEST(string_util::format("%H:%M", params) == "%H:%M"); 68 BOOST_TEST(string_util::format("%H:%M", params) == "%H:%M");
69 } 69 }
70 70
71 BOOST_AUTO_TEST_CASE(disable_keywords) 71 BOOST_AUTO_TEST_CASE(disable_keywords)
72 { 72 {
73 string_util::subst params; 73 string_util::subst params;
74 74
75 params.keywords.emplace("target", "hello"); 75 params.keywords.emplace("target", "hello");
76 params.flags &= ~(string_util::subst_flags::keywords); 76 params.flags &= ~(string_util::subst_flags::keywords);
77 77
78 BOOST_TEST(string_util::format("#{target}", params) == "#{target}"); 78 BOOST_TEST(string_util::format("#{target}", params) == "#{target}");
79 } 79 }
80 80
81 BOOST_AUTO_TEST_CASE(disable_env) 81 BOOST_AUTO_TEST_CASE(disable_env)
82 { 82 {
83 string_util::subst params; 83 string_util::subst params;
84 84
85 params.flags &= ~(string_util::subst_flags::env); 85 params.flags &= ~(string_util::subst_flags::env);
86 86
87 BOOST_TEST(string_util::format("${HOME}", params) == "${HOME}"); 87 BOOST_TEST(string_util::format("${HOME}", params) == "${HOME}");
88 } 88 }
89 89
90 BOOST_AUTO_TEST_CASE(keyword_simple) 90 BOOST_AUTO_TEST_CASE(keyword_simple)
91 { 91 {
92 string_util::subst params; 92 string_util::subst params;
93 93
94 params.keywords.insert({"target", "irccd"}); 94 params.keywords.insert({"target", "irccd"});
95 95
96 std::string expected = "hello irccd!"; 96 std::string expected = "hello irccd!";
97 std::string result = string_util::format("hello #{target}!", params); 97 std::string result = string_util::format("hello #{target}!", params);
98 98
99 BOOST_TEST(expected == result); 99 BOOST_TEST(expected == result);
100 } 100 }
101 101
102 BOOST_AUTO_TEST_CASE(keyword_multiple) 102 BOOST_AUTO_TEST_CASE(keyword_multiple)
103 { 103 {
104 string_util::subst params; 104 string_util::subst params;
105 105
106 params.keywords.insert({"target", "irccd"}); 106 params.keywords.insert({"target", "irccd"});
107 params.keywords.insert({"source", "nightmare"}); 107 params.keywords.insert({"source", "nightmare"});
108 108
109 std::string expected = "hello irccd from nightmare!"; 109 std::string expected = "hello irccd from nightmare!";
110 std::string result = string_util::format("hello #{target} from #{source}!", params); 110 std::string result = string_util::format("hello #{target} from #{source}!", params);
111 111
112 BOOST_TEST(expected == result); 112 BOOST_TEST(expected == result);
113 } 113 }
114 114
115 BOOST_AUTO_TEST_CASE(keyword_adj_twice) 115 BOOST_AUTO_TEST_CASE(keyword_adj_twice)
116 { 116 {
117 string_util::subst params; 117 string_util::subst params;
118 118
119 params.keywords.insert({"target", "irccd"}); 119 params.keywords.insert({"target", "irccd"});
120 120
121 std::string expected = "hello irccdirccd!"; 121 std::string expected = "hello irccdirccd!";
122 std::string result = string_util::format("hello #{target}#{target}!", params); 122 std::string result = string_util::format("hello #{target}#{target}!", params);
123 123
124 BOOST_TEST(expected == result); 124 BOOST_TEST(expected == result);
125 } 125 }
126 126
127 BOOST_AUTO_TEST_CASE(keyword_missing) 127 BOOST_AUTO_TEST_CASE(keyword_missing)
128 { 128 {
129 std::string expected = "hello !"; 129 std::string expected = "hello !";
130 std::string result = string_util::format("hello #{target}!"); 130 std::string result = string_util::format("hello #{target}!");
131 131
132 BOOST_TEST(expected == result); 132 BOOST_TEST(expected == result);
133 } 133 }
134 134
135 BOOST_AUTO_TEST_CASE(env_simple) 135 BOOST_AUTO_TEST_CASE(env_simple)
136 { 136 {
137 std::string home = sys::env("HOME"); 137 std::string home = sys::env("HOME");
138 138
139 if (!home.empty()) { 139 if (!home.empty()) {
140 std::string expected = "my home is " + home; 140 std::string expected = "my home is " + home;
141 std::string result = string_util::format("my home is ${HOME}"); 141 std::string result = string_util::format("my home is ${HOME}");
142 142
143 BOOST_TEST(expected == result); 143 BOOST_TEST(expected == result);
144 } 144 }
145 } 145 }
146 146
147 BOOST_AUTO_TEST_CASE(env_missing) 147 BOOST_AUTO_TEST_CASE(env_missing)
148 { 148 {
149 std::string expected = "value is "; 149 std::string expected = "value is ";
150 std::string result = string_util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}"); 150 std::string result = string_util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}");
151 151
152 BOOST_TEST(expected == result); 152 BOOST_TEST(expected == result);
153 } 153 }
154 154
155 BOOST_AUTO_TEST_SUITE_END() 155 BOOST_AUTO_TEST_SUITE_END()
156 156
157 /* 157 /*
163 163
164 using list = std::vector<std::string>; 164 using list = std::vector<std::string>;
165 165
166 BOOST_AUTO_TEST_CASE(simple) 166 BOOST_AUTO_TEST_CASE(simple)
167 { 167 {
168 list expected { "a", "b" }; 168 list expected { "a", "b" };
169 list result = string_util::split("a;b", ";"); 169 list result = string_util::split("a;b", ";");
170 170
171 BOOST_TEST(expected == result); 171 BOOST_TEST(expected == result);
172 } 172 }
173 173
174 BOOST_AUTO_TEST_CASE(cut) 174 BOOST_AUTO_TEST_CASE(cut)
175 { 175 {
176 list expected { "msg", "#staff", "foo bar baz" }; 176 list expected { "msg", "#staff", "foo bar baz" };
177 list result = string_util::split("msg;#staff;foo bar baz", ";", 3); 177 list result = string_util::split("msg;#staff;foo bar baz", ";", 3);
178 178
179 BOOST_TEST(expected == result); 179 BOOST_TEST(expected == result);
180 } 180 }
181 181
182 BOOST_AUTO_TEST_SUITE_END() 182 BOOST_AUTO_TEST_SUITE_END()
183 183
184 /* 184 /*
188 188
189 BOOST_AUTO_TEST_SUITE(strip) 189 BOOST_AUTO_TEST_SUITE(strip)
190 190
191 BOOST_AUTO_TEST_CASE(left) 191 BOOST_AUTO_TEST_CASE(left)
192 { 192 {
193 std::string value = " 123"; 193 std::string value = " 123";
194 std::string result = string_util::strip(value); 194 std::string result = string_util::strip(value);
195 195
196 BOOST_TEST(result == "123"); 196 BOOST_TEST(result == "123");
197 } 197 }
198 198
199 BOOST_AUTO_TEST_CASE(right) 199 BOOST_AUTO_TEST_CASE(right)
200 { 200 {
201 std::string value = "123 "; 201 std::string value = "123 ";
202 std::string result = string_util::strip(value); 202 std::string result = string_util::strip(value);
203 203
204 BOOST_TEST(result == "123"); 204 BOOST_TEST(result == "123");
205 } 205 }
206 206
207 BOOST_AUTO_TEST_CASE(both) 207 BOOST_AUTO_TEST_CASE(both)
208 { 208 {
209 std::string value = " 123 "; 209 std::string value = " 123 ";
210 std::string result = string_util::strip(value); 210 std::string result = string_util::strip(value);
211 211
212 BOOST_TEST(result == "123"); 212 BOOST_TEST(result == "123");
213 } 213 }
214 214
215 BOOST_AUTO_TEST_CASE(none) 215 BOOST_AUTO_TEST_CASE(none)
216 { 216 {
217 std::string value = "without"; 217 std::string value = "without";
218 std::string result = string_util::strip(value); 218 std::string result = string_util::strip(value);
219 219
220 BOOST_TEST(result == "without"); 220 BOOST_TEST(result == "without");
221 } 221 }
222 222
223 BOOST_AUTO_TEST_CASE(between_empty) 223 BOOST_AUTO_TEST_CASE(between_empty)
224 { 224 {
225 std::string value = "one list"; 225 std::string value = "one list";
226 std::string result = string_util::strip(value); 226 std::string result = string_util::strip(value);
227 227
228 BOOST_TEST(result == "one list"); 228 BOOST_TEST(result == "one list");
229 } 229 }
230 230
231 BOOST_AUTO_TEST_CASE(between_left) 231 BOOST_AUTO_TEST_CASE(between_left)
232 { 232 {
233 std::string value = " space at left"; 233 std::string value = " space at left";
234 std::string result = string_util::strip(value); 234 std::string result = string_util::strip(value);
235 235
236 BOOST_TEST(result == "space at left"); 236 BOOST_TEST(result == "space at left");
237 } 237 }
238 238
239 BOOST_AUTO_TEST_CASE(between_right) 239 BOOST_AUTO_TEST_CASE(between_right)
240 { 240 {
241 std::string value = "space at right "; 241 std::string value = "space at right ";
242 std::string result = string_util::strip(value); 242 std::string result = string_util::strip(value);
243 243
244 BOOST_TEST(result == "space at right"); 244 BOOST_TEST(result == "space at right");
245 } 245 }
246 246
247 BOOST_AUTO_TEST_CASE(between_both) 247 BOOST_AUTO_TEST_CASE(between_both)
248 { 248 {
249 std::string value = " space at both "; 249 std::string value = " space at both ";
250 std::string result = string_util::strip(value); 250 std::string result = string_util::strip(value);
251 251
252 BOOST_TEST(result == "space at both"); 252 BOOST_TEST(result == "space at both");
253 } 253 }
254 254
255 BOOST_AUTO_TEST_CASE(empty) 255 BOOST_AUTO_TEST_CASE(empty)
256 { 256 {
257 std::string value = " "; 257 std::string value = " ";
258 std::string result = string_util::strip(value); 258 std::string result = string_util::strip(value);
259 259
260 BOOST_TEST(result == ""); 260 BOOST_TEST(result == "");
261 } 261 }
262 262
263 BOOST_AUTO_TEST_SUITE_END() 263 BOOST_AUTO_TEST_SUITE_END()
264 264
265 /* 265 /*
269 269
270 BOOST_AUTO_TEST_SUITE(join) 270 BOOST_AUTO_TEST_SUITE(join)
271 271
272 BOOST_AUTO_TEST_CASE(empty) 272 BOOST_AUTO_TEST_CASE(empty)
273 { 273 {
274 std::string expected = ""; 274 std::string expected = "";
275 std::string result = string_util::join<int>({}); 275 std::string result = string_util::join<int>({});
276 276
277 BOOST_TEST(expected == result); 277 BOOST_TEST(expected == result);
278 } 278 }
279 279
280 BOOST_AUTO_TEST_CASE(one) 280 BOOST_AUTO_TEST_CASE(one)
281 { 281 {
282 std::string expected = "1"; 282 std::string expected = "1";
283 std::string result = string_util::join({1}); 283 std::string result = string_util::join({1});
284 284
285 BOOST_TEST(expected == result); 285 BOOST_TEST(expected == result);
286 } 286 }
287 287
288 BOOST_AUTO_TEST_CASE(two) 288 BOOST_AUTO_TEST_CASE(two)
289 { 289 {
290 std::string expected = "1:2"; 290 std::string expected = "1:2";
291 std::string result = string_util::join({1, 2}); 291 std::string result = string_util::join({1, 2});
292 292
293 BOOST_TEST(expected == result); 293 BOOST_TEST(expected == result);
294 } 294 }
295 295
296 BOOST_AUTO_TEST_CASE(delimiter_string) 296 BOOST_AUTO_TEST_CASE(delimiter_string)
297 { 297 {
298 std::string expected = "1;;2;;3"; 298 std::string expected = "1;;2;;3";
299 std::string result = string_util::join({1, 2, 3}, ";;"); 299 std::string result = string_util::join({1, 2, 3}, ";;");
300 300
301 BOOST_TEST(expected == result); 301 BOOST_TEST(expected == result);
302 } 302 }
303 303
304 BOOST_AUTO_TEST_CASE(delimiter_char) 304 BOOST_AUTO_TEST_CASE(delimiter_char)
305 { 305 {
306 std::string expected = "1@2@3@4"; 306 std::string expected = "1@2@3@4";
307 std::string result = string_util::join({1, 2, 3, 4}, '@'); 307 std::string result = string_util::join({1, 2, 3, 4}, '@');
308 308
309 BOOST_TEST(expected == result); 309 BOOST_TEST(expected == result);
310 } 310 }
311 311
312 BOOST_AUTO_TEST_SUITE_END() 312 BOOST_AUTO_TEST_SUITE_END()
313 313
314 /* 314 /*
318 318
319 BOOST_AUTO_TEST_SUITE(is_identifier_valid) 319 BOOST_AUTO_TEST_SUITE(is_identifier_valid)
320 320
321 BOOST_AUTO_TEST_CASE(correct) 321 BOOST_AUTO_TEST_CASE(correct)
322 { 322 {
323 BOOST_TEST(string_util::is_identifier("localhost")); 323 BOOST_TEST(string_util::is_identifier("localhost"));
324 BOOST_TEST(string_util::is_identifier("localhost2")); 324 BOOST_TEST(string_util::is_identifier("localhost2"));
325 BOOST_TEST(string_util::is_identifier("localhost2-4_")); 325 BOOST_TEST(string_util::is_identifier("localhost2-4_"));
326 } 326 }
327 327
328 BOOST_AUTO_TEST_CASE(incorrect) 328 BOOST_AUTO_TEST_CASE(incorrect)
329 { 329 {
330 BOOST_TEST(!string_util::is_identifier("")); 330 BOOST_TEST(!string_util::is_identifier(""));
331 BOOST_TEST(!string_util::is_identifier("localhost with spaces")); 331 BOOST_TEST(!string_util::is_identifier("localhost with spaces"));
332 BOOST_TEST(!string_util::is_identifier("localhost*")); 332 BOOST_TEST(!string_util::is_identifier("localhost*"));
333 BOOST_TEST(!string_util::is_identifier("&&")); 333 BOOST_TEST(!string_util::is_identifier("&&"));
334 BOOST_TEST(!string_util::is_identifier("@'")); 334 BOOST_TEST(!string_util::is_identifier("@'"));
335 BOOST_TEST(!string_util::is_identifier("##")); 335 BOOST_TEST(!string_util::is_identifier("##"));
336 BOOST_TEST(!string_util::is_identifier("===++")); 336 BOOST_TEST(!string_util::is_identifier("===++"));
337 } 337 }
338 338
339 BOOST_AUTO_TEST_SUITE_END() 339 BOOST_AUTO_TEST_SUITE_END()
340 340
341 /* 341 /*
345 345
346 BOOST_AUTO_TEST_SUITE(is_boolean) 346 BOOST_AUTO_TEST_SUITE(is_boolean)
347 347
348 BOOST_AUTO_TEST_CASE(correct) 348 BOOST_AUTO_TEST_CASE(correct)
349 { 349 {
350 // true 350 // true
351 BOOST_TEST(string_util::is_boolean("true")); 351 BOOST_TEST(string_util::is_boolean("true"));
352 BOOST_TEST(string_util::is_boolean("True")); 352 BOOST_TEST(string_util::is_boolean("True"));
353 BOOST_TEST(string_util::is_boolean("TRUE")); 353 BOOST_TEST(string_util::is_boolean("TRUE"));
354 BOOST_TEST(string_util::is_boolean("TruE")); 354 BOOST_TEST(string_util::is_boolean("TruE"));
355 355
356 // yes 356 // yes
357 BOOST_TEST(string_util::is_boolean("yes")); 357 BOOST_TEST(string_util::is_boolean("yes"));
358 BOOST_TEST(string_util::is_boolean("Yes")); 358 BOOST_TEST(string_util::is_boolean("Yes"));
359 BOOST_TEST(string_util::is_boolean("YES")); 359 BOOST_TEST(string_util::is_boolean("YES"));
360 BOOST_TEST(string_util::is_boolean("YeS")); 360 BOOST_TEST(string_util::is_boolean("YeS"));
361 361
362 // on 362 // on
363 BOOST_TEST(string_util::is_boolean("on")); 363 BOOST_TEST(string_util::is_boolean("on"));
364 BOOST_TEST(string_util::is_boolean("On")); 364 BOOST_TEST(string_util::is_boolean("On"));
365 BOOST_TEST(string_util::is_boolean("oN")); 365 BOOST_TEST(string_util::is_boolean("oN"));
366 BOOST_TEST(string_util::is_boolean("ON")); 366 BOOST_TEST(string_util::is_boolean("ON"));
367 367
368 // 1 368 // 1
369 BOOST_TEST(string_util::is_boolean("1")); 369 BOOST_TEST(string_util::is_boolean("1"));
370 } 370 }
371 371
372 BOOST_AUTO_TEST_CASE(incorrect) 372 BOOST_AUTO_TEST_CASE(incorrect)
373 { 373 {
374 BOOST_TEST(!string_util::is_boolean("false")); 374 BOOST_TEST(!string_util::is_boolean("false"));
375 BOOST_TEST(!string_util::is_boolean("lol")); 375 BOOST_TEST(!string_util::is_boolean("lol"));
376 BOOST_TEST(!string_util::is_boolean("")); 376 BOOST_TEST(!string_util::is_boolean(""));
377 BOOST_TEST(!string_util::is_boolean("0")); 377 BOOST_TEST(!string_util::is_boolean("0"));
378 } 378 }
379 379
380 BOOST_AUTO_TEST_SUITE_END() 380 BOOST_AUTO_TEST_SUITE_END()
381 381
382 } // !namespace 382 } // !namespace