Line data Source code
1 : // Copyright (c) 2006-2022 Made to Order Software Corp. All Rights Reserved
2 : //
3 : // https://snapwebsites.org/project/advgetopt
4 : // contact@m2osw.com
5 : //
6 : // This program is free software; you can redistribute it and/or modify
7 : // it under the terms of the GNU General Public License as published by
8 : // the Free Software Foundation; either version 2 of the License, or
9 : // (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License along
17 : // with this program; if not, write to the Free Software Foundation, Inc.,
18 : // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 :
20 : // self
21 : //
22 : #include "catch_main.h"
23 :
24 :
25 : // advgetopt lib
26 : //
27 : #include <advgetopt/exception.h>
28 :
29 :
30 : // libutf8 lib
31 : //
32 : #include <libutf8/libutf8.h>
33 :
34 :
35 : // C++ lib
36 : //
37 : #include <fstream>
38 :
39 :
40 : // last include
41 : //
42 : #include <snapdev/poison.h>
43 :
44 :
45 :
46 :
47 :
48 29 : CATCH_TEST_CASE("option_info_ref", "[option_info][valid][reference]")
49 : {
50 54 : CATCH_START_SECTION("Option info reference")
51 : {
52 1 : advgetopt::option const options[] =
53 : {
54 : advgetopt::define_option(
55 : advgetopt::Name("reference")
56 : , advgetopt::ShortName('r')
57 : , advgetopt::Flags(advgetopt::command_flags<
58 : advgetopt::GETOPT_FLAG_REQUIRED
59 : | advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
60 : , advgetopt::Help("test reference.")
61 : ),
62 : advgetopt::define_option(
63 : advgetopt::Name("verbose")
64 : , advgetopt::ShortName('v')
65 : , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
66 : , advgetopt::Help("make it all verbose.")
67 : ),
68 : advgetopt::end_options()
69 : };
70 :
71 1 : advgetopt::options_environment environment_options;
72 1 : environment_options.f_project_name = "unittest";
73 1 : environment_options.f_options = options;
74 1 : environment_options.f_help_header = "Usage: verify references";
75 :
76 1 : char const * cargv[] =
77 : {
78 : "/usr/bin/arguments",
79 : "--reference",
80 : "1001",
81 : "--verbose",
82 : "loud",
83 : nullptr
84 : };
85 1 : int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
86 1 : char ** argv = const_cast<char **>(cargv);
87 :
88 2 : advgetopt::getopt opt(environment_options, argc, argv);
89 :
90 : // check that the result is valid
91 :
92 : // verify both parameters the "normal" way
93 1 : CATCH_REQUIRE(opt.get_option("reference") != nullptr);
94 1 : CATCH_REQUIRE(opt.size("reference") == 1);
95 1 : CATCH_REQUIRE(opt.get_string("reference") == "1001");
96 :
97 1 : CATCH_REQUIRE(opt.get_option("verbose") != nullptr);
98 1 : CATCH_REQUIRE(opt.size("verbose") == 1);
99 1 : CATCH_REQUIRE(opt.get_string("verbose") == "loud");
100 :
101 : // check the read-only verbose which does not create a reference
102 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["reference"] == "1001");
103 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["verbose"] == "loud");
104 :
105 2 : std::string const reference_value(const_cast<advgetopt::getopt const &>(opt)["reference"]);
106 1 : CATCH_REQUIRE(reference_value == "1001");
107 2 : std::string const verbose_value(const_cast<advgetopt::getopt const &>(opt)["verbose"]);
108 1 : CATCH_REQUIRE(verbose_value == "loud");
109 :
110 : // get a reference
111 2 : advgetopt::option_info_ref reference_ref(opt["reference"]);
112 2 : advgetopt::option_info_ref verbose_ref(opt["verbose"]);
113 :
114 1 : CATCH_REQUIRE_FALSE(reference_ref.empty());
115 1 : CATCH_REQUIRE_FALSE(verbose_ref.empty());
116 :
117 1 : CATCH_REQUIRE(reference_ref.length() == 4);
118 1 : CATCH_REQUIRE(reference_ref.size() == 4);
119 1 : CATCH_REQUIRE(verbose_ref.length() == 4);
120 1 : CATCH_REQUIRE(verbose_ref.size() == 4);
121 :
122 1 : CATCH_REQUIRE(reference_ref == reference_ref);
123 1 : CATCH_REQUIRE_FALSE(reference_ref != reference_ref);
124 1 : CATCH_REQUIRE_FALSE(reference_ref < reference_ref);
125 1 : CATCH_REQUIRE(reference_ref <= reference_ref);
126 1 : CATCH_REQUIRE_FALSE(reference_ref > reference_ref);
127 1 : CATCH_REQUIRE(reference_ref >= reference_ref);
128 :
129 1 : CATCH_REQUIRE_FALSE(reference_ref == verbose_ref);
130 1 : CATCH_REQUIRE(reference_ref != verbose_ref);
131 1 : CATCH_REQUIRE(reference_ref < verbose_ref);
132 1 : CATCH_REQUIRE(reference_ref <= verbose_ref);
133 1 : CATCH_REQUIRE_FALSE(reference_ref > verbose_ref);
134 1 : CATCH_REQUIRE_FALSE(reference_ref >= verbose_ref);
135 :
136 1 : reference_ref += "3";
137 1 : CATCH_REQUIRE(reference_ref == "10013");
138 1 : CATCH_REQUIRE("10013" == reference_ref);
139 1 : CATCH_REQUIRE(reference_ref != "17013");
140 1 : CATCH_REQUIRE("10413" != reference_ref);
141 1 : CATCH_REQUIRE(reference_ref < "20");
142 1 : CATCH_REQUIRE("1001" < reference_ref);
143 1 : CATCH_REQUIRE(reference_ref <= "10013");
144 1 : CATCH_REQUIRE("10013" <= reference_ref);
145 1 : CATCH_REQUIRE(reference_ref > "%");
146 1 : CATCH_REQUIRE("10014" > reference_ref);
147 1 : CATCH_REQUIRE(reference_ref >= "!");
148 1 : CATCH_REQUIRE("10013" >= reference_ref);
149 :
150 2 : std::string const new_value("zero");
151 1 : reference_ref = new_value;
152 1 : CATCH_REQUIRE(reference_ref == reference_ref);
153 1 : CATCH_REQUIRE(reference_ref == new_value);
154 1 : CATCH_REQUIRE(new_value == reference_ref);
155 1 : CATCH_REQUIRE_FALSE(reference_ref != new_value);
156 1 : CATCH_REQUIRE_FALSE(new_value != reference_ref);
157 1 : CATCH_REQUIRE_FALSE(reference_ref < new_value);
158 1 : CATCH_REQUIRE_FALSE(new_value < reference_ref);
159 1 : CATCH_REQUIRE(reference_ref <= new_value);
160 1 : CATCH_REQUIRE(new_value <= reference_ref);
161 1 : CATCH_REQUIRE_FALSE(reference_ref > new_value);
162 1 : CATCH_REQUIRE_FALSE(new_value > reference_ref);
163 1 : CATCH_REQUIRE(reference_ref >= new_value);
164 1 : CATCH_REQUIRE(new_value >= reference_ref);
165 :
166 1 : reference_ref += verbose_ref;
167 1 : CATCH_REQUIRE(reference_ref == reference_ref);
168 1 : CATCH_REQUIRE(reference_ref == "zeroloud");
169 1 : CATCH_REQUIRE("zeroloud" == reference_ref);
170 1 : CATCH_REQUIRE_FALSE(reference_ref != "zeroloud");
171 1 : CATCH_REQUIRE_FALSE("zeroloud" != reference_ref);
172 1 : CATCH_REQUIRE_FALSE(reference_ref < "zeroloud");
173 1 : CATCH_REQUIRE_FALSE("zeroloud" < reference_ref);
174 1 : CATCH_REQUIRE(reference_ref <= "zeroloud");
175 1 : CATCH_REQUIRE("zeroloud" <= reference_ref);
176 1 : CATCH_REQUIRE_FALSE(reference_ref > "zeroloud");
177 1 : CATCH_REQUIRE_FALSE("zeroloud" > reference_ref);
178 1 : CATCH_REQUIRE(reference_ref >= "zeroloud");
179 1 : CATCH_REQUIRE("zeroloud" >= reference_ref);
180 :
181 1 : reference_ref += '?';
182 1 : CATCH_REQUIRE(reference_ref == reference_ref);
183 1 : CATCH_REQUIRE(reference_ref == "zeroloud?");
184 1 : CATCH_REQUIRE("zeroloud?" == reference_ref);
185 1 : CATCH_REQUIRE_FALSE(reference_ref != "zeroloud?");
186 1 : CATCH_REQUIRE_FALSE("zeroloud?" != reference_ref);
187 1 : CATCH_REQUIRE_FALSE(reference_ref < "zeroloud?");
188 1 : CATCH_REQUIRE_FALSE("zeroloud?" < reference_ref);
189 1 : CATCH_REQUIRE(reference_ref <= "zeroloud?");
190 1 : CATCH_REQUIRE("zeroloud?" <= reference_ref);
191 1 : CATCH_REQUIRE_FALSE(reference_ref > "zeroloud?");
192 1 : CATCH_REQUIRE_FALSE("zeroloud?" > reference_ref);
193 1 : CATCH_REQUIRE(reference_ref >= "zeroloud?");
194 1 : CATCH_REQUIRE("zeroloud?" >= reference_ref);
195 :
196 1 : CATCH_REQUIRE_FALSE(reference_ref + "more" == reference_ref);
197 1 : CATCH_REQUIRE(reference_ref + "more" == "zeroloud?more");
198 1 : CATCH_REQUIRE("zeroloud?more" == reference_ref + "more");
199 1 : CATCH_REQUIRE(reference_ref + std::string("extra") == "zeroloud?extra");
200 1 : CATCH_REQUIRE("zeroloud?extra" == reference_ref + std::string("extra"));
201 1 : CATCH_REQUIRE(reference_ref + verbose_ref == "zeroloud?loud");
202 1 : CATCH_REQUIRE("zeroloud?loud" == reference_ref + verbose_ref);
203 :
204 1 : CATCH_REQUIRE_FALSE(reference_ref + '+' == reference_ref);
205 1 : CATCH_REQUIRE(reference_ref + '+' == "zeroloud?+");
206 1 : CATCH_REQUIRE("zeroloud?+" == reference_ref + '+');
207 1 : CATCH_REQUIRE('+' + reference_ref == "+zeroloud?");
208 1 : CATCH_REQUIRE("+zeroloud?" == '+' + reference_ref);
209 :
210 1 : CATCH_REQUIRE(reference_ref + '\0' == reference_ref);
211 1 : CATCH_REQUIRE(reference_ref + '\0' == "zeroloud?");
212 1 : CATCH_REQUIRE("zeroloud?" == reference_ref + '\0');
213 1 : CATCH_REQUIRE('\0' + reference_ref == "zeroloud?");
214 1 : CATCH_REQUIRE("zeroloud?" == '\0' + reference_ref);
215 :
216 1 : char32_t c(rand() % 0xFFFFF + ' ');
217 1 : if(c >= 0xD800 && c < 0xE000)
218 : {
219 0 : c += 0x800;
220 : }
221 :
222 1 : CATCH_REQUIRE_FALSE(reference_ref + c == reference_ref);
223 1 : CATCH_REQUIRE(reference_ref + c == "zeroloud?" + libutf8::to_u8string(c));
224 1 : CATCH_REQUIRE("zeroloud?" + libutf8::to_u8string(c) == reference_ref + c);
225 1 : CATCH_REQUIRE(c + reference_ref == libutf8::to_u8string(c) + "zeroloud?");
226 1 : CATCH_REQUIRE(libutf8::to_u8string(c) + "zeroloud?" == c + reference_ref);
227 :
228 1 : c = U'\0';
229 :
230 1 : CATCH_REQUIRE(reference_ref + c == reference_ref);
231 1 : CATCH_REQUIRE(reference_ref + c == "zeroloud?");
232 1 : CATCH_REQUIRE("zeroloud?" == reference_ref + c);
233 1 : CATCH_REQUIRE(c + reference_ref == "zeroloud?");
234 1 : CATCH_REQUIRE("zeroloud?" == c + reference_ref);
235 :
236 1 : reference_ref = "reset";
237 1 : CATCH_REQUIRE('"' + reference_ref + '"' == "\"reset\"");
238 1 : CATCH_REQUIRE('\0' + reference_ref + '\0' == std::string("reset") + '\0'); // we do not control the second + here...
239 1 : CATCH_REQUIRE(c + reference_ref + c == "reset");
240 :
241 1 : reference_ref = verbose_ref;
242 1 : CATCH_REQUIRE('(' + reference_ref + ')' == "(loud)");
243 1 : CATCH_REQUIRE('\0' + reference_ref + '\0' == std::string("loud") + '\0'); // we do not control the second + here...
244 1 : CATCH_REQUIRE(c + reference_ref + c == "loud");
245 :
246 2 : std::string const secret("secret");
247 1 : reference_ref += ' ';
248 1 : reference_ref += secret;
249 1 : CATCH_REQUIRE('>' + reference_ref + '<' == ">loud secret<");
250 1 : char32_t const left(0x1D233);
251 1 : char32_t const right(0x1D234);
252 1 : CATCH_REQUIRE((left + (reference_ref + right)) == "\xF0\x9D\x88\xB3loud secret\xF0\x9D\x88\xB4");
253 1 : CATCH_REQUIRE(((left + reference_ref) + right) == "\xF0\x9D\x88\xB3loud secret\xF0\x9D\x88\xB4");
254 1 : CATCH_REQUIRE(c == U'\0');
255 1 : CATCH_REQUIRE((c + (reference_ref + c)) == "loud secret");
256 1 : CATCH_REQUIRE(((c + reference_ref) + c) == "loud secret");
257 1 : CATCH_REQUIRE(reference_ref + new_value == "loud secretzero");
258 1 : CATCH_REQUIRE(new_value + reference_ref == "zeroloud secret");
259 1 : CATCH_REQUIRE(reference_ref + " more" == "loud secret more");
260 1 : CATCH_REQUIRE("less " + reference_ref == "less loud secret");
261 :
262 1 : reference_ref = '#';
263 1 : CATCH_REQUIRE(reference_ref == "#");
264 1 : reference_ref += '\0';
265 1 : CATCH_REQUIRE(reference_ref == "#");
266 1 : reference_ref += c;
267 1 : CATCH_REQUIRE(reference_ref == "#");
268 :
269 1 : reference_ref = '\0';
270 1 : CATCH_REQUIRE(reference_ref == "");
271 :
272 1 : reference_ref = '?';
273 1 : CATCH_REQUIRE(reference_ref == "?");
274 1 : reference_ref += '\0';
275 1 : CATCH_REQUIRE(reference_ref == "?");
276 1 : reference_ref += c;
277 1 : CATCH_REQUIRE(reference_ref == "?");
278 :
279 1 : reference_ref = c;
280 1 : CATCH_REQUIRE(reference_ref == "");
281 : }
282 : CATCH_END_SECTION()
283 :
284 54 : CATCH_START_SECTION("Non-existant reference")
285 : {
286 1 : advgetopt::option const options[] =
287 : {
288 : advgetopt::define_option(
289 : advgetopt::Name("reference")
290 : , advgetopt::ShortName('r')
291 : , advgetopt::Flags(advgetopt::command_flags<
292 : advgetopt::GETOPT_FLAG_REQUIRED
293 : | advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
294 : , advgetopt::Help("test reference.")
295 : ),
296 : advgetopt::define_option(
297 : advgetopt::Name("verbose")
298 : , advgetopt::ShortName('v')
299 : , advgetopt::Flags(advgetopt::command_flags<
300 : advgetopt::GETOPT_FLAG_REQUIRED
301 : | advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
302 : , advgetopt::Help("make it all verbose.")
303 : ),
304 : advgetopt::end_options()
305 : };
306 :
307 1 : advgetopt::options_environment environment_options;
308 1 : environment_options.f_project_name = "unittest";
309 1 : environment_options.f_options = options;
310 1 : environment_options.f_help_header = "Usage: verify references";
311 :
312 1 : char const * cargv[] =
313 : {
314 : "/usr/bin/arguments",
315 : "--reference",
316 : "1001",
317 : "--verbose",
318 : "loud",
319 : nullptr
320 : };
321 1 : int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
322 1 : char ** argv = const_cast<char **>(cargv);
323 :
324 2 : advgetopt::getopt opt(environment_options, argc, argv);
325 :
326 : // check that the result is valid
327 :
328 : // verify both parameters the "normal" way
329 1 : CATCH_REQUIRE(opt.get_option("reference") != nullptr);
330 1 : CATCH_REQUIRE(opt.size("reference") == 1);
331 1 : CATCH_REQUIRE(opt.get_string("reference") == "1001");
332 :
333 1 : CATCH_REQUIRE(opt.get_option("verbose") != nullptr);
334 1 : CATCH_REQUIRE(opt.size("verbose") == 1);
335 1 : CATCH_REQUIRE(opt.get_string("verbose") == "loud");
336 :
337 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
338 :
339 : // check the read-only verbose which does not create a reference
340 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["reference"] == "1001");
341 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["verbose"] == "loud");
342 :
343 2 : std::string const reference_value(const_cast<advgetopt::getopt const &>(opt)["reference"]);
344 1 : CATCH_REQUIRE(reference_value == "1001");
345 2 : std::string const verbose_value(const_cast<advgetopt::getopt const &>(opt)["verbose"]);
346 1 : CATCH_REQUIRE(verbose_value == "loud");
347 :
348 : // get references
349 2 : advgetopt::option_info_ref unknown_ref(opt["unknown"]);
350 2 : advgetopt::option_info_ref reference_ref(opt["reference"]);
351 2 : advgetopt::option_info_ref verbose_ref(opt["verbose"]);
352 :
353 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
354 :
355 1 : char const * null_string(nullptr);
356 :
357 1 : CATCH_REQUIRE(unknown_ref.empty());
358 1 : CATCH_REQUIRE(unknown_ref.length() == 0);
359 1 : CATCH_REQUIRE(unknown_ref.size() == 0);
360 1 : CATCH_REQUIRE(unknown_ref.get_long() == 0);
361 1 : CATCH_REQUIRE(static_cast<std::string>(unknown_ref) == "");
362 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
363 :
364 1 : CATCH_REQUIRE_FALSE(static_cast<bool>(unknown_ref));
365 1 : CATCH_REQUIRE(!unknown_ref);
366 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
367 :
368 1 : CATCH_REQUIRE(unknown_ref == nullptr);
369 1 : CATCH_REQUIRE(unknown_ref == "");
370 1 : CATCH_REQUIRE(unknown_ref == std::string());
371 1 : CATCH_REQUIRE_FALSE(unknown_ref == std::string("test"));
372 1 : CATCH_REQUIRE(nullptr == unknown_ref);
373 1 : CATCH_REQUIRE("" == unknown_ref);
374 1 : CATCH_REQUIRE(std::string() == unknown_ref);
375 1 : CATCH_REQUIRE_FALSE(std::string("test") == unknown_ref);
376 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
377 :
378 1 : CATCH_REQUIRE_FALSE(unknown_ref != nullptr);
379 1 : CATCH_REQUIRE_FALSE(unknown_ref != "");
380 1 : CATCH_REQUIRE_FALSE(unknown_ref != std::string());
381 1 : CATCH_REQUIRE(unknown_ref != std::string("test"));
382 1 : CATCH_REQUIRE_FALSE(nullptr != unknown_ref);
383 1 : CATCH_REQUIRE_FALSE("" != unknown_ref);
384 1 : CATCH_REQUIRE_FALSE(std::string() != unknown_ref);
385 1 : CATCH_REQUIRE(std::string("test") != unknown_ref);
386 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
387 :
388 1 : CATCH_REQUIRE_FALSE(unknown_ref < nullptr);
389 1 : CATCH_REQUIRE_FALSE(unknown_ref < "");
390 1 : CATCH_REQUIRE_FALSE(unknown_ref < std::string());
391 1 : CATCH_REQUIRE(unknown_ref < std::string("test"));
392 1 : CATCH_REQUIRE_FALSE(nullptr < unknown_ref);
393 1 : CATCH_REQUIRE_FALSE("" < unknown_ref);
394 1 : CATCH_REQUIRE_FALSE(std::string() < unknown_ref);
395 1 : CATCH_REQUIRE_FALSE(std::string("test") < unknown_ref);
396 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
397 :
398 1 : CATCH_REQUIRE(unknown_ref <= nullptr);
399 1 : CATCH_REQUIRE(unknown_ref <= "");
400 1 : CATCH_REQUIRE(unknown_ref <= std::string());
401 1 : CATCH_REQUIRE(unknown_ref <= std::string("test"));
402 1 : CATCH_REQUIRE(nullptr <= unknown_ref);
403 1 : CATCH_REQUIRE("" <= unknown_ref);
404 1 : CATCH_REQUIRE(std::string() <= unknown_ref);
405 1 : CATCH_REQUIRE_FALSE(std::string("test") <= unknown_ref);
406 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
407 :
408 1 : CATCH_REQUIRE_FALSE(unknown_ref > nullptr);
409 1 : CATCH_REQUIRE_FALSE(unknown_ref > "");
410 1 : CATCH_REQUIRE_FALSE(unknown_ref > std::string());
411 1 : CATCH_REQUIRE_FALSE(unknown_ref > std::string("test"));
412 1 : CATCH_REQUIRE_FALSE(nullptr > unknown_ref);
413 1 : CATCH_REQUIRE_FALSE("" > unknown_ref);
414 1 : CATCH_REQUIRE_FALSE(std::string() > unknown_ref);
415 1 : CATCH_REQUIRE(std::string("test") > unknown_ref);
416 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
417 :
418 1 : CATCH_REQUIRE(unknown_ref >= nullptr);
419 1 : CATCH_REQUIRE(unknown_ref >= "");
420 1 : CATCH_REQUIRE(unknown_ref >= std::string());
421 1 : CATCH_REQUIRE_FALSE(unknown_ref >= std::string("test"));
422 1 : CATCH_REQUIRE(nullptr >= unknown_ref);
423 1 : CATCH_REQUIRE("" >= unknown_ref);
424 1 : CATCH_REQUIRE(std::string() >= unknown_ref);
425 1 : CATCH_REQUIRE(std::string("test") >= unknown_ref);
426 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
427 :
428 1 : CATCH_REQUIRE(unknown_ref + '\0' == "");
429 1 : CATCH_REQUIRE(unknown_ref + '<' == "<");
430 1 : CATCH_REQUIRE(unknown_ref + static_cast<char32_t>(U'\0') == "");
431 1 : CATCH_REQUIRE(unknown_ref + static_cast<char32_t>(U'\x2020') == "\xE2\x80\xA0");
432 1 : CATCH_REQUIRE(unknown_ref + null_string == "");
433 1 : CATCH_REQUIRE(unknown_ref + "abc\xE4\x81\x81" == "abc\xE4\x81\x81");
434 1 : CATCH_REQUIRE(unknown_ref + std::string("xyz\xE4\x9E\x99") == "xyz\xE4\x9E\x99");
435 1 : CATCH_REQUIRE(unknown_ref + reference_ref == "1001");
436 1 : CATCH_REQUIRE(unknown_ref + verbose_ref == "loud");
437 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
438 :
439 1 : CATCH_REQUIRE('\0' + unknown_ref == "");
440 1 : CATCH_REQUIRE('<' + unknown_ref == "<");
441 1 : CATCH_REQUIRE(static_cast<char32_t>(U'\0') + unknown_ref == "");
442 1 : CATCH_REQUIRE(static_cast<char32_t>(U'\x2020') + unknown_ref == "\xE2\x80\xA0");
443 1 : CATCH_REQUIRE(null_string + unknown_ref == "");
444 1 : CATCH_REQUIRE("abc\xE4\x81\x81" + unknown_ref == "abc\xE4\x81\x81");
445 1 : CATCH_REQUIRE(std::string("xyz\xE4\x9E\x99") + unknown_ref == "xyz\xE4\x9E\x99");
446 1 : CATCH_REQUIRE(reference_ref + unknown_ref == "1001");
447 1 : CATCH_REQUIRE(verbose_ref + unknown_ref == "loud");
448 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
449 :
450 1 : unknown_ref = static_cast<char32_t>(U'\x4819'); // == '\xE4\xA0\x99'
451 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
452 :
453 1 : CATCH_REQUIRE_FALSE(unknown_ref.empty());
454 1 : CATCH_REQUIRE(unknown_ref.length() == 3); // 3 UTF-8 bytes
455 1 : CATCH_REQUIRE(unknown_ref.size() == 3);
456 :
457 1 : SNAP_CATCH2_NAMESPACE::push_expected_log("error: invalid number (\xE4\xA0\x99) in parameter --unknown at offset 0.");
458 1 : CATCH_REQUIRE(unknown_ref.get_long() == -1);
459 1 : SNAP_CATCH2_NAMESPACE::expected_logs_stack_is_empty();
460 :
461 1 : CATCH_REQUIRE(static_cast<std::string>(unknown_ref) == "\xE4\xA0\x99");
462 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
463 :
464 1 : CATCH_REQUIRE(static_cast<bool>(unknown_ref));
465 1 : CATCH_REQUIRE_FALSE(!unknown_ref);
466 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
467 :
468 1 : CATCH_REQUIRE_FALSE(unknown_ref == nullptr);
469 1 : CATCH_REQUIRE_FALSE(unknown_ref == "");
470 1 : CATCH_REQUIRE(unknown_ref == "\xE4\xA0\x99");
471 1 : CATCH_REQUIRE_FALSE(unknown_ref == std::string());
472 1 : CATCH_REQUIRE_FALSE(unknown_ref == std::string("test"));
473 1 : CATCH_REQUIRE(unknown_ref == std::string("\xE4\xA0\x99"));
474 1 : CATCH_REQUIRE_FALSE(nullptr == unknown_ref);
475 1 : CATCH_REQUIRE_FALSE("" == unknown_ref);
476 1 : CATCH_REQUIRE("\xE4\xA0\x99" == unknown_ref);
477 1 : CATCH_REQUIRE_FALSE(std::string() == unknown_ref);
478 1 : CATCH_REQUIRE_FALSE(std::string("test") == unknown_ref);
479 1 : CATCH_REQUIRE(std::string("\xE4\xA0\x99") == unknown_ref);
480 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
481 :
482 1 : CATCH_REQUIRE(unknown_ref != nullptr);
483 1 : CATCH_REQUIRE(unknown_ref != "");
484 1 : CATCH_REQUIRE_FALSE(unknown_ref != "\xE4\xA0\x99");
485 1 : CATCH_REQUIRE(unknown_ref != std::string());
486 1 : CATCH_REQUIRE(unknown_ref != std::string("test"));
487 1 : CATCH_REQUIRE_FALSE(unknown_ref != std::string("\xE4\xA0\x99"));
488 1 : CATCH_REQUIRE(nullptr != unknown_ref);
489 1 : CATCH_REQUIRE("" != unknown_ref);
490 1 : CATCH_REQUIRE_FALSE("\xE4\xA0\x99" != unknown_ref);
491 1 : CATCH_REQUIRE(std::string() != unknown_ref);
492 1 : CATCH_REQUIRE(std::string("test") != unknown_ref);
493 1 : CATCH_REQUIRE_FALSE(std::string("\xE4\xA0\x99") != unknown_ref);
494 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
495 :
496 1 : CATCH_REQUIRE_FALSE(unknown_ref < nullptr);
497 1 : CATCH_REQUIRE_FALSE(unknown_ref < "");
498 1 : CATCH_REQUIRE_FALSE(unknown_ref < "\xE4\xA0\x99");
499 1 : CATCH_REQUIRE_FALSE(unknown_ref < std::string());
500 1 : CATCH_REQUIRE_FALSE(unknown_ref < std::string("test"));
501 1 : CATCH_REQUIRE_FALSE(unknown_ref < std::string("\xE4\xA0\x99"));
502 1 : CATCH_REQUIRE(nullptr < unknown_ref);
503 1 : CATCH_REQUIRE("" < unknown_ref);
504 1 : CATCH_REQUIRE_FALSE("\xE4\xA0\x99" < unknown_ref);
505 1 : CATCH_REQUIRE(std::string() < unknown_ref);
506 1 : CATCH_REQUIRE(std::string("test") < unknown_ref);
507 1 : CATCH_REQUIRE_FALSE(std::string("\xE4\xA0\x99") < unknown_ref);
508 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
509 :
510 1 : CATCH_REQUIRE_FALSE(unknown_ref <= nullptr);
511 1 : CATCH_REQUIRE_FALSE(unknown_ref <= "");
512 1 : CATCH_REQUIRE(unknown_ref <= "\xE4\xA0\x99");
513 1 : CATCH_REQUIRE_FALSE(unknown_ref <= std::string());
514 1 : CATCH_REQUIRE_FALSE(unknown_ref <= std::string("test"));
515 1 : CATCH_REQUIRE(unknown_ref <= std::string("\xE4\xA0\x99"));
516 1 : CATCH_REQUIRE(nullptr <= unknown_ref);
517 1 : CATCH_REQUIRE("" <= unknown_ref);
518 1 : CATCH_REQUIRE("\xE4\xA0\x99" <= unknown_ref);
519 1 : CATCH_REQUIRE(std::string() <= unknown_ref);
520 1 : CATCH_REQUIRE(std::string("test") <= unknown_ref);
521 1 : CATCH_REQUIRE(std::string("\xE4\xA0\x99") <= unknown_ref);
522 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
523 :
524 1 : CATCH_REQUIRE(unknown_ref > nullptr);
525 1 : CATCH_REQUIRE(unknown_ref > "");
526 1 : CATCH_REQUIRE_FALSE(unknown_ref > "\xE4\xA0\x99");
527 1 : CATCH_REQUIRE(unknown_ref > std::string());
528 1 : CATCH_REQUIRE(unknown_ref > std::string("test"));
529 1 : CATCH_REQUIRE_FALSE(unknown_ref > std::string("\xE4\xA0\x99"));
530 1 : CATCH_REQUIRE_FALSE(nullptr > unknown_ref);
531 1 : CATCH_REQUIRE_FALSE("" > unknown_ref);
532 1 : CATCH_REQUIRE_FALSE("\xE4\xA0\x99" > unknown_ref);
533 1 : CATCH_REQUIRE_FALSE(std::string() > unknown_ref);
534 1 : CATCH_REQUIRE_FALSE(std::string("test") > unknown_ref);
535 1 : CATCH_REQUIRE_FALSE(std::string("\xE4\xA0\x99") > unknown_ref);
536 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
537 :
538 1 : CATCH_REQUIRE(unknown_ref >= nullptr);
539 1 : CATCH_REQUIRE(unknown_ref >= "");
540 1 : CATCH_REQUIRE(unknown_ref >= "\xE4\xA0\x99");
541 1 : CATCH_REQUIRE(unknown_ref >= std::string());
542 1 : CATCH_REQUIRE(unknown_ref >= std::string("test"));
543 1 : CATCH_REQUIRE(unknown_ref >= std::string("\xE4\xA0\x99"));
544 1 : CATCH_REQUIRE_FALSE(nullptr >= unknown_ref);
545 1 : CATCH_REQUIRE_FALSE("" >= unknown_ref);
546 1 : CATCH_REQUIRE_FALSE(std::string() >= unknown_ref);
547 1 : CATCH_REQUIRE_FALSE(std::string("test") >= unknown_ref);
548 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
549 :
550 1 : CATCH_REQUIRE(unknown_ref + '\0' == "\xE4\xA0\x99");
551 1 : CATCH_REQUIRE(unknown_ref + '<' == "\xE4\xA0\x99<");
552 1 : CATCH_REQUIRE(unknown_ref + static_cast<char32_t>(U'\0') == "\xE4\xA0\x99");
553 1 : CATCH_REQUIRE(unknown_ref + static_cast<char32_t>(U'\x2020') == "\xE4\xA0\x99\xE2\x80\xA0");
554 1 : CATCH_REQUIRE(unknown_ref + null_string == "\xE4\xA0\x99");
555 1 : CATCH_REQUIRE(unknown_ref + "abc\xE4\x81\x81" == "\xE4\xA0\x99\x61\x62\x63\xE4\x81\x81");
556 1 : CATCH_REQUIRE(unknown_ref + std::string("xyz\xE4\x9E\x99") == "\xE4\xA0\x99xyz\xE4\x9E\x99");
557 1 : CATCH_REQUIRE(unknown_ref + reference_ref == "\xE4\xA0\x99\x31\x30\x30\x31");
558 1 : CATCH_REQUIRE(unknown_ref + verbose_ref == "\xE4\xA0\x99loud");
559 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
560 :
561 1 : CATCH_REQUIRE('\0' + unknown_ref == "\xE4\xA0\x99");
562 1 : CATCH_REQUIRE('<' + unknown_ref == "<\xE4\xA0\x99");
563 1 : CATCH_REQUIRE(static_cast<char32_t>(U'\0') + unknown_ref == "\xE4\xA0\x99");
564 1 : CATCH_REQUIRE(static_cast<char32_t>(U'\x2020') + unknown_ref == "\xE2\x80\xA0\xE4\xA0\x99");
565 1 : CATCH_REQUIRE(null_string + unknown_ref == "\xE4\xA0\x99");
566 1 : CATCH_REQUIRE("abc\xE4\x81\x81" + unknown_ref == "abc\xE4\x81\x81\xE4\xA0\x99");
567 1 : CATCH_REQUIRE(std::string("xyz\xE4\x9E\x99") + unknown_ref == "xyz\xE4\x9E\x99\xE4\xA0\x99");
568 1 : CATCH_REQUIRE(reference_ref + unknown_ref == "1001\xE4\xA0\x99");
569 1 : CATCH_REQUIRE(verbose_ref + unknown_ref == "loud\xE4\xA0\x99");
570 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
571 : }
572 : CATCH_END_SECTION()
573 :
574 54 : CATCH_START_SECTION("Set non-existant reference + many CATCH_WHEN()")
575 : {
576 25 : advgetopt::option const options[] =
577 : {
578 : advgetopt::define_option(
579 : advgetopt::Name("reference")
580 : , advgetopt::ShortName('r')
581 : , advgetopt::Flags(advgetopt::command_flags<
582 : advgetopt::GETOPT_FLAG_REQUIRED
583 : | advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
584 : , advgetopt::Help("test reference.")
585 : , advgetopt::DefaultValue("978")
586 : ),
587 : advgetopt::define_option(
588 : advgetopt::Name("verbose")
589 : , advgetopt::ShortName('v')
590 : , advgetopt::Flags(advgetopt::command_flags<
591 : advgetopt::GETOPT_FLAG_REQUIRED
592 : | advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
593 : , advgetopt::Help("make it all verbose.")
594 : ),
595 : advgetopt::end_options()
596 : };
597 :
598 25 : advgetopt::options_environment environment_options;
599 25 : environment_options.f_project_name = "unittest";
600 25 : environment_options.f_options = options;
601 25 : environment_options.f_help_header = "Usage: verify references";
602 :
603 25 : char const * cargv[] =
604 : {
605 : "/usr/bin/arguments",
606 : "--reference",
607 : "3100",
608 : "--verbose",
609 : "silence",
610 : nullptr
611 : };
612 25 : int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
613 25 : char ** argv = const_cast<char **>(cargv);
614 :
615 50 : advgetopt::getopt opt(environment_options, argc, argv);
616 :
617 : // check that the result is valid
618 :
619 : // verify both parameters the "normal" way
620 25 : CATCH_REQUIRE(opt.get_option("reference") != nullptr);
621 25 : CATCH_REQUIRE(opt.size("reference") == 1);
622 25 : CATCH_REQUIRE(opt.get_string("reference") == "3100");
623 25 : CATCH_REQUIRE(opt.get_long("reference") == 3100);
624 :
625 25 : CATCH_REQUIRE(opt.get_option("verbose") != nullptr);
626 25 : CATCH_REQUIRE(opt.size("verbose") == 1);
627 25 : CATCH_REQUIRE(opt.get_string("verbose") == "silence");
628 :
629 25 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
630 :
631 : // check the read-only verbose which does not create a reference
632 25 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["reference"] == "3100");
633 25 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["verbose"] == "silence");
634 :
635 50 : std::string const reference_value(const_cast<advgetopt::getopt const &>(opt)["reference"]);
636 25 : CATCH_REQUIRE(reference_value == "3100");
637 50 : std::string const verbose_value(const_cast<advgetopt::getopt const &>(opt)["verbose"]);
638 25 : CATCH_REQUIRE(verbose_value == "silence");
639 :
640 : // get references
641 50 : advgetopt::option_info_ref unknown_ref(opt["unknown"]);
642 50 : advgetopt::option_info_ref undefined_ref(opt["undefined"]); // never set, used as rhs to test setting/adding with an undefined ref.
643 50 : advgetopt::option_info_ref reference_ref(opt["reference"]);
644 50 : advgetopt::option_info_ref verbose_ref(opt["verbose"]);
645 :
646 25 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
647 25 : CATCH_REQUIRE(opt.is_defined("reference"));
648 25 : CATCH_REQUIRE(opt.is_defined("verbose"));
649 25 : CATCH_REQUIRE(reference_ref.get_long() == 3100);
650 :
651 50 : CATCH_WHEN("with = & zero char")
652 : {
653 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
654 :
655 1 : char const c('\0');
656 1 : unknown_ref = c;
657 :
658 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
659 :
660 2 : std::string s;
661 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
662 :
663 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
664 1 : CATCH_REQUIRE(unknown_value == s);
665 :
666 1 : CATCH_REQUIRE(unknown_ref == s);
667 :
668 1 : unknown_ref += c;
669 :
670 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
671 :
672 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
673 :
674 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
675 1 : CATCH_REQUIRE(unknown_value2 == s);
676 :
677 1 : CATCH_REQUIRE(unknown_ref == s);
678 : }
679 :
680 50 : CATCH_WHEN("with = & valid char")
681 : {
682 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
683 :
684 1 : char const c(rand() % 26 + 'a');
685 1 : unknown_ref = c;
686 :
687 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
688 :
689 2 : std::string s;
690 1 : s += c;
691 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
692 :
693 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
694 1 : CATCH_REQUIRE(unknown_value == s);
695 :
696 1 : CATCH_REQUIRE(unknown_ref == s);
697 :
698 1 : char const d(rand() % 26 + 'a');
699 1 : unknown_ref += d;
700 :
701 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
702 :
703 1 : s += d;
704 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
705 :
706 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
707 1 : CATCH_REQUIRE(unknown_value2 == s);
708 :
709 1 : CATCH_REQUIRE(unknown_ref == s);
710 : }
711 :
712 50 : CATCH_WHEN("with = & zero char32_t")
713 : {
714 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
715 :
716 1 : char32_t const c(U'\0');
717 1 : unknown_ref = c;
718 :
719 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
720 :
721 2 : std::string s;
722 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
723 :
724 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
725 1 : CATCH_REQUIRE(unknown_value == s);
726 :
727 1 : CATCH_REQUIRE(unknown_ref == s);
728 :
729 1 : unknown_ref += c;
730 :
731 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
732 :
733 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
734 :
735 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
736 1 : CATCH_REQUIRE(unknown_value2 == s);
737 :
738 1 : CATCH_REQUIRE(unknown_ref == s);
739 : }
740 :
741 50 : CATCH_WHEN("with = & valid char32_t")
742 : {
743 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
744 :
745 1 : char32_t c((rand() & 0xFFFFF) + ' ');
746 1 : if(c >= 0xD800 && c < 0xE000)
747 : {
748 0 : c += 0x0800;
749 : }
750 1 : unknown_ref = c;
751 :
752 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
753 :
754 2 : std::string s;
755 1 : s += libutf8::to_u8string(c);
756 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
757 :
758 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
759 1 : CATCH_REQUIRE(unknown_value == s);
760 :
761 1 : CATCH_REQUIRE(unknown_ref == s);
762 :
763 1 : char32_t d((rand() & 0xFFFFF) + ' ');
764 1 : if(d >= 0xD800 && d < 0xE000)
765 : {
766 0 : d += 0x0800;
767 : }
768 1 : unknown_ref += d;
769 :
770 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
771 :
772 1 : s += libutf8::to_u8string(d);
773 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
774 :
775 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
776 1 : CATCH_REQUIRE(unknown_value2 == s);
777 :
778 1 : CATCH_REQUIRE(unknown_ref == s);
779 : }
780 :
781 50 : CATCH_WHEN("with = & nullptr of 'char const *'")
782 : {
783 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
784 :
785 1 : char const * str(nullptr);
786 1 : unknown_ref = str;
787 :
788 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
789 :
790 2 : std::string s;
791 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
792 :
793 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
794 1 : CATCH_REQUIRE(unknown_value == s);
795 :
796 1 : CATCH_REQUIRE(unknown_ref == s);
797 :
798 1 : unknown_ref += str;
799 :
800 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
801 :
802 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
803 :
804 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
805 1 : CATCH_REQUIRE(unknown_value2 == s);
806 :
807 1 : CATCH_REQUIRE(unknown_ref == s);
808 : }
809 :
810 50 : CATCH_WHEN("with = & empty 'char const *' string")
811 : {
812 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
813 :
814 1 : char const * str("");
815 1 : unknown_ref = str;
816 :
817 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
818 :
819 2 : std::string s;
820 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
821 :
822 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
823 1 : CATCH_REQUIRE(unknown_value == s);
824 :
825 1 : CATCH_REQUIRE(unknown_ref == s);
826 :
827 1 : unknown_ref += str;
828 :
829 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
830 :
831 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
832 :
833 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
834 1 : CATCH_REQUIRE(unknown_value2 == s);
835 :
836 1 : CATCH_REQUIRE(unknown_ref == s);
837 : }
838 :
839 50 : CATCH_WHEN("with = & valid `char const *`")
840 : {
841 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
842 :
843 2 : std::string str;
844 1 : size_t max(rand() % 10 + 1);
845 4 : for(size_t idx(0); idx < max; ++idx)
846 : {
847 3 : char32_t c((rand() & 0xFFFFF) + ' ');
848 3 : if(c >= 0xD800 && c < 0xE000)
849 : {
850 0 : c += 0x0800;
851 : }
852 3 : str += libutf8::to_u8string(c);
853 : }
854 1 : unknown_ref = str.c_str();
855 :
856 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
857 :
858 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
859 :
860 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
861 1 : CATCH_REQUIRE(unknown_value == str);
862 :
863 1 : CATCH_REQUIRE(unknown_ref == str);
864 :
865 2 : std::string add;
866 1 : max = rand() % 10 + 1;
867 5 : for(size_t idx(0); idx < max; ++idx)
868 : {
869 4 : char32_t c((rand() & 0xFFFFF) + ' ');
870 4 : if(c >= 0xD800 && c < 0xE000)
871 : {
872 0 : c += 0x0800;
873 : }
874 4 : add += libutf8::to_u8string(c);
875 : }
876 1 : unknown_ref += add.c_str();
877 :
878 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
879 :
880 1 : str += add;
881 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
882 :
883 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
884 1 : CATCH_REQUIRE(unknown_value2 == str);
885 :
886 1 : CATCH_REQUIRE(unknown_ref == str);
887 : }
888 :
889 50 : CATCH_WHEN("with = & empty std::string")
890 : {
891 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
892 :
893 2 : std::string str;
894 1 : unknown_ref = str;
895 :
896 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
897 :
898 2 : std::string s;
899 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
900 :
901 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
902 1 : CATCH_REQUIRE(unknown_value == s);
903 :
904 1 : CATCH_REQUIRE(unknown_ref == s);
905 :
906 1 : unknown_ref += str;
907 :
908 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
909 :
910 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
911 :
912 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
913 1 : CATCH_REQUIRE(unknown_value2 == s);
914 :
915 1 : CATCH_REQUIRE(unknown_ref == s);
916 : }
917 :
918 50 : CATCH_WHEN("with = & valid std::string")
919 : {
920 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
921 :
922 2 : std::string str;
923 1 : size_t max(rand() % 10 + 1);
924 4 : for(size_t idx(0); idx < max; ++idx)
925 : {
926 3 : char32_t c((rand() & 0xFFFFF) + ' ');
927 3 : if(c >= 0xD800 && c < 0xE000)
928 : {
929 0 : c += 0x0800;
930 : }
931 3 : str += libutf8::to_u8string(c);
932 : }
933 1 : unknown_ref = str;
934 :
935 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
936 :
937 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
938 :
939 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
940 1 : CATCH_REQUIRE(unknown_value == str);
941 :
942 1 : CATCH_REQUIRE(unknown_ref == str);
943 :
944 2 : std::string add;
945 1 : max = rand() % 10 + 1;
946 5 : for(size_t idx(0); idx < max; ++idx)
947 : {
948 4 : char32_t c((rand() & 0xFFFFF) + ' ');
949 4 : if(c >= 0xD800 && c < 0xE000)
950 : {
951 0 : c += 0x0800;
952 : }
953 4 : add += libutf8::to_u8string(c);
954 : }
955 1 : unknown_ref += add;
956 :
957 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
958 :
959 1 : str += add;
960 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
961 :
962 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
963 1 : CATCH_REQUIRE(unknown_value2 == str);
964 :
965 1 : CATCH_REQUIRE(unknown_ref == str);
966 : }
967 :
968 50 : CATCH_WHEN("with = & unknown reference")
969 : {
970 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
971 :
972 1 : unknown_ref = undefined_ref;
973 :
974 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
975 :
976 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == "");
977 :
978 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
979 1 : CATCH_REQUIRE(unknown_value == std::string());
980 :
981 1 : CATCH_REQUIRE(unknown_ref == std::string());
982 : }
983 :
984 50 : CATCH_WHEN("with = & self reference")
985 : {
986 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
987 :
988 1 : unknown_ref = unknown_ref;
989 :
990 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
991 :
992 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == "");
993 :
994 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
995 1 : CATCH_REQUIRE(unknown_value == std::string());
996 :
997 1 : CATCH_REQUIRE(unknown_ref == std::string());
998 :
999 1 : CATCH_REQUIRE(unknown_ref == unknown_ref);
1000 : }
1001 :
1002 50 : CATCH_WHEN("with = & known reference")
1003 : {
1004 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1005 :
1006 1 : unknown_ref = verbose_ref;
1007 :
1008 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1009 :
1010 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == verbose_value);
1011 :
1012 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1013 1 : CATCH_REQUIRE(unknown_value == verbose_value);
1014 :
1015 1 : CATCH_REQUIRE(unknown_ref == verbose_value);
1016 :
1017 1 : unknown_ref += reference_ref;
1018 :
1019 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1020 :
1021 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == verbose_value + reference_value);
1022 :
1023 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1024 1 : CATCH_REQUIRE(unknown_value2 == verbose_value + reference_value);
1025 :
1026 1 : CATCH_REQUIRE(unknown_ref == verbose_value + reference_value);
1027 : }
1028 :
1029 50 : CATCH_WHEN("with += & zero char")
1030 : {
1031 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1032 :
1033 1 : char const c('\0');
1034 1 : unknown_ref += c;
1035 :
1036 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1037 :
1038 2 : std::string s;
1039 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1040 :
1041 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1042 1 : CATCH_REQUIRE(unknown_value == s);
1043 :
1044 1 : CATCH_REQUIRE(unknown_ref == s);
1045 : }
1046 :
1047 50 : CATCH_WHEN("with += & valid char")
1048 : {
1049 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1050 :
1051 1 : char const c(rand() % 26 + 'a');
1052 1 : unknown_ref += c;
1053 :
1054 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1055 :
1056 2 : std::string s;
1057 1 : s += c;
1058 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1059 :
1060 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1061 1 : CATCH_REQUIRE(unknown_value == s);
1062 :
1063 1 : CATCH_REQUIRE(unknown_ref == s);
1064 : }
1065 :
1066 50 : CATCH_WHEN("with += & zero char32_t")
1067 : {
1068 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1069 :
1070 1 : char32_t const c(U'\0');
1071 1 : unknown_ref += c;
1072 :
1073 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1074 :
1075 2 : std::string s;
1076 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1077 :
1078 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1079 1 : CATCH_REQUIRE(unknown_value == s);
1080 :
1081 1 : CATCH_REQUIRE(unknown_ref == s);
1082 : }
1083 :
1084 50 : CATCH_WHEN("with += & valid char32_t")
1085 : {
1086 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1087 :
1088 1 : char32_t c((rand() & 0xFFFFF) + ' ');
1089 1 : if(c >= 0xD800 && c < 0xE000)
1090 : {
1091 0 : c += 0x0800;
1092 : }
1093 :
1094 1 : unknown_ref += c;
1095 :
1096 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1097 :
1098 2 : std::string s;
1099 1 : s += libutf8::to_u8string(c);
1100 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1101 :
1102 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1103 1 : CATCH_REQUIRE(unknown_value == s);
1104 :
1105 1 : CATCH_REQUIRE(unknown_ref == s);
1106 : }
1107 :
1108 50 : CATCH_WHEN("with += & nullptr of 'char const *'")
1109 : {
1110 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1111 :
1112 1 : char const * str(nullptr);
1113 :
1114 1 : unknown_ref += str;
1115 :
1116 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1117 :
1118 2 : std::string s;
1119 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1120 :
1121 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1122 1 : CATCH_REQUIRE(unknown_value2 == s);
1123 :
1124 1 : CATCH_REQUIRE(unknown_ref == s);
1125 : }
1126 :
1127 50 : CATCH_WHEN("with += & empty 'char const *' string")
1128 : {
1129 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1130 :
1131 1 : char const * str("");
1132 :
1133 1 : unknown_ref += str;
1134 :
1135 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1136 :
1137 2 : std::string s;
1138 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1139 :
1140 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1141 1 : CATCH_REQUIRE(unknown_value == s);
1142 :
1143 1 : CATCH_REQUIRE(unknown_ref == s);
1144 : }
1145 :
1146 50 : CATCH_WHEN("with += & valid `char const *`")
1147 : {
1148 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1149 :
1150 2 : std::string str;
1151 1 : size_t max(rand() % 10 + 1);
1152 4 : for(size_t idx(0); idx < max; ++idx)
1153 : {
1154 3 : char32_t c((rand() & 0xFFFFF) + ' ');
1155 3 : if(c >= 0xD800 && c < 0xE000)
1156 : {
1157 0 : c += 0x0800;
1158 : }
1159 3 : str += libutf8::to_u8string(c);
1160 : }
1161 :
1162 1 : unknown_ref += str.c_str();
1163 :
1164 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1165 :
1166 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
1167 :
1168 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1169 1 : CATCH_REQUIRE(unknown_value == str);
1170 :
1171 1 : CATCH_REQUIRE(unknown_ref == str);
1172 : }
1173 :
1174 50 : CATCH_WHEN("with += & empty std::string")
1175 : {
1176 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1177 :
1178 2 : std::string str;
1179 1 : unknown_ref += str;
1180 :
1181 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1182 :
1183 2 : std::string s;
1184 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == s);
1185 :
1186 2 : std::string const unknown_value2(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1187 1 : CATCH_REQUIRE(unknown_value2 == s);
1188 :
1189 1 : CATCH_REQUIRE(unknown_ref == s);
1190 : }
1191 :
1192 50 : CATCH_WHEN("with += & valid std::string")
1193 : {
1194 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1195 :
1196 2 : std::string str;
1197 1 : size_t max(rand() % 10 + 1);
1198 4 : for(size_t idx(0); idx < max; ++idx)
1199 : {
1200 3 : char32_t c((rand() & 0xFFFFF) + ' ');
1201 3 : if(c >= 0xD800 && c < 0xE000)
1202 : {
1203 0 : c += 0x0800;
1204 : }
1205 3 : str += libutf8::to_u8string(c);
1206 : }
1207 1 : unknown_ref += str;
1208 :
1209 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1210 :
1211 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == str);
1212 :
1213 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1214 1 : CATCH_REQUIRE(unknown_value == str);
1215 :
1216 1 : CATCH_REQUIRE(unknown_ref == str);
1217 : }
1218 :
1219 50 : CATCH_WHEN("with += & unknown reference")
1220 : {
1221 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1222 :
1223 1 : unknown_ref += undefined_ref;
1224 :
1225 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1226 :
1227 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == "");
1228 :
1229 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1230 1 : CATCH_REQUIRE(unknown_value == std::string());
1231 :
1232 1 : CATCH_REQUIRE(unknown_ref == std::string());
1233 : }
1234 :
1235 50 : CATCH_WHEN("with += & self reference")
1236 : {
1237 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1238 :
1239 1 : unknown_ref += unknown_ref;
1240 :
1241 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1242 :
1243 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == "");
1244 :
1245 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1246 1 : CATCH_REQUIRE(unknown_value == std::string());
1247 :
1248 1 : CATCH_REQUIRE(unknown_ref == std::string());
1249 :
1250 1 : CATCH_REQUIRE(unknown_ref == unknown_ref);
1251 : }
1252 :
1253 50 : CATCH_WHEN("with += & known reference")
1254 : {
1255 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1256 :
1257 1 : unknown_ref += reference_ref;
1258 :
1259 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1260 :
1261 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == reference_value);
1262 :
1263 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1264 1 : CATCH_REQUIRE(unknown_value == reference_value);
1265 :
1266 1 : CATCH_REQUIRE(unknown_ref == reference_value);
1267 : }
1268 :
1269 50 : CATCH_WHEN("with += & self reference")
1270 : {
1271 1 : CATCH_REQUIRE_FALSE(opt.is_defined("unknown"));
1272 :
1273 1 : unknown_ref += unknown_ref;
1274 :
1275 1 : CATCH_REQUIRE(opt.is_defined("unknown"));
1276 :
1277 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["unknown"] == "");
1278 :
1279 2 : std::string const unknown_value(const_cast<advgetopt::getopt const &>(opt)["unknown"]);
1280 1 : CATCH_REQUIRE(unknown_value == "");
1281 :
1282 1 : CATCH_REQUIRE(unknown_ref == "");
1283 : }
1284 : }
1285 : CATCH_END_SECTION()
1286 27 : }
1287 :
1288 :
1289 :
1290 3 : CATCH_TEST_CASE("option_info_ref_with_valid_default", "[option_info][valid][reference][long][default]")
1291 : {
1292 2 : CATCH_START_SECTION("No reference on command line, valid default for get_long()")
1293 : {
1294 1 : advgetopt::option const options[] =
1295 : {
1296 : advgetopt::define_option(
1297 : advgetopt::Name("reference")
1298 : , advgetopt::ShortName('r')
1299 : , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
1300 : , advgetopt::Help("test reference.")
1301 : , advgetopt::DefaultValue("459")
1302 : ),
1303 : advgetopt::define_option(
1304 : advgetopt::Name("verbose")
1305 : , advgetopt::ShortName('v')
1306 : , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
1307 : , advgetopt::Help("make it all verbose.")
1308 : ),
1309 : advgetopt::end_options()
1310 : };
1311 :
1312 1 : advgetopt::options_environment environment_options;
1313 1 : environment_options.f_project_name = "unittest";
1314 1 : environment_options.f_options = options;
1315 1 : environment_options.f_help_header = "Usage: verify references";
1316 :
1317 1 : char const * cargv[] =
1318 : {
1319 : "/usr/bin/arguments",
1320 : "--verbose",
1321 : "loud",
1322 : nullptr
1323 : };
1324 1 : int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
1325 1 : char ** argv = const_cast<char **>(cargv);
1326 :
1327 2 : advgetopt::getopt opt(environment_options, argc, argv);
1328 :
1329 : // check that the result is valid
1330 :
1331 : // verify both parameters the "normal" way
1332 1 : CATCH_REQUIRE(opt.get_option("reference") != nullptr);
1333 1 : CATCH_REQUIRE(opt.size("reference") == 0);
1334 1 : CATCH_REQUIRE(opt.get_string("reference") == "459");
1335 :
1336 1 : CATCH_REQUIRE(opt.get_option("verbose") != nullptr);
1337 1 : CATCH_REQUIRE(opt.size("verbose") == 1);
1338 1 : CATCH_REQUIRE(opt.get_string("verbose") == "loud");
1339 :
1340 : // check the read-only verbose which does not create a reference
1341 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["reference"] == "459");
1342 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["verbose"] == "loud");
1343 :
1344 2 : std::string const reference_value(const_cast<advgetopt::getopt const &>(opt)["reference"]);
1345 1 : CATCH_REQUIRE(reference_value == "459");
1346 2 : std::string const verbose_value(const_cast<advgetopt::getopt const &>(opt)["verbose"]);
1347 1 : CATCH_REQUIRE(verbose_value == "loud");
1348 :
1349 : // get a reference
1350 2 : advgetopt::option_info_ref reference_ref(opt["reference"]);
1351 2 : advgetopt::option_info_ref verbose_ref(opt["verbose"]);
1352 :
1353 1 : CATCH_REQUIRE(reference_ref.empty());
1354 1 : CATCH_REQUIRE_FALSE(verbose_ref.empty());
1355 :
1356 1 : CATCH_REQUIRE(reference_ref.length() == 3);
1357 1 : CATCH_REQUIRE(reference_ref.size() == 3);
1358 1 : CATCH_REQUIRE(verbose_ref.length() == 4);
1359 1 : CATCH_REQUIRE(verbose_ref.size() == 4);
1360 :
1361 1 : CATCH_REQUIRE(reference_ref.get_long() == 459);
1362 :
1363 1 : CATCH_REQUIRE(reference_ref == reference_ref);
1364 1 : CATCH_REQUIRE_FALSE(reference_ref != reference_ref);
1365 1 : CATCH_REQUIRE_FALSE(reference_ref < reference_ref);
1366 1 : CATCH_REQUIRE(reference_ref <= reference_ref);
1367 1 : CATCH_REQUIRE_FALSE(reference_ref > reference_ref);
1368 1 : CATCH_REQUIRE(reference_ref >= reference_ref);
1369 :
1370 1 : CATCH_REQUIRE_FALSE(reference_ref == verbose_ref);
1371 1 : CATCH_REQUIRE(reference_ref != verbose_ref);
1372 1 : CATCH_REQUIRE(reference_ref < verbose_ref);
1373 1 : CATCH_REQUIRE(reference_ref <= verbose_ref);
1374 1 : CATCH_REQUIRE_FALSE(reference_ref > verbose_ref);
1375 1 : CATCH_REQUIRE_FALSE(reference_ref >= verbose_ref);
1376 : }
1377 : CATCH_END_SECTION()
1378 1 : }
1379 :
1380 :
1381 :
1382 3 : CATCH_TEST_CASE("option_info_ref_with_invalid_default", "[option_info][invalid][reference][long][default]")
1383 : {
1384 2 : CATCH_START_SECTION("No reference on command line, not valid for get_long()")
1385 : {
1386 1 : advgetopt::option const options[] =
1387 : {
1388 : advgetopt::define_option(
1389 : advgetopt::Name("reference")
1390 : , advgetopt::ShortName('r')
1391 : , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
1392 : , advgetopt::Help("test reference.")
1393 : , advgetopt::DefaultValue("undefined")
1394 : ),
1395 : advgetopt::define_option(
1396 : advgetopt::Name("verbose")
1397 : , advgetopt::ShortName('v')
1398 : , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
1399 : , advgetopt::Help("make it all verbose.")
1400 : ),
1401 : advgetopt::end_options()
1402 : };
1403 :
1404 1 : advgetopt::options_environment environment_options;
1405 1 : environment_options.f_project_name = "unittest";
1406 1 : environment_options.f_options = options;
1407 1 : environment_options.f_help_header = "Usage: verify references";
1408 :
1409 1 : char const * cargv[] =
1410 : {
1411 : "/usr/bin/arguments",
1412 : "--verbose",
1413 : "loud",
1414 : nullptr
1415 : };
1416 1 : int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
1417 1 : char ** argv = const_cast<char **>(cargv);
1418 :
1419 2 : advgetopt::getopt opt(environment_options, argc, argv);
1420 :
1421 : // check that the result is valid
1422 :
1423 : // verify both parameters the "normal" way
1424 1 : CATCH_REQUIRE(opt.get_option("reference") != nullptr);
1425 1 : CATCH_REQUIRE(opt.size("reference") == 0);
1426 1 : CATCH_REQUIRE(opt.get_string("reference") == "undefined");
1427 :
1428 1 : CATCH_REQUIRE(opt.get_option("verbose") != nullptr);
1429 1 : CATCH_REQUIRE(opt.size("verbose") == 1);
1430 1 : CATCH_REQUIRE(opt.get_string("verbose") == "loud");
1431 :
1432 : // check the read-only verbose which does not create a reference
1433 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["reference"] == "undefined");
1434 1 : CATCH_REQUIRE(const_cast<advgetopt::getopt const &>(opt)["verbose"] == "loud");
1435 :
1436 2 : std::string const reference_value(const_cast<advgetopt::getopt const &>(opt)["reference"]);
1437 1 : CATCH_REQUIRE(reference_value == "undefined");
1438 2 : std::string const verbose_value(const_cast<advgetopt::getopt const &>(opt)["verbose"]);
1439 1 : CATCH_REQUIRE(verbose_value == "loud");
1440 :
1441 : // get a reference
1442 2 : advgetopt::option_info_ref reference_ref(opt["reference"]);
1443 2 : advgetopt::option_info_ref verbose_ref(opt["verbose"]);
1444 :
1445 1 : CATCH_REQUIRE(reference_ref.empty());
1446 1 : CATCH_REQUIRE_FALSE(verbose_ref.empty());
1447 :
1448 1 : CATCH_REQUIRE(reference_ref.length() == 9);
1449 1 : CATCH_REQUIRE(reference_ref.size() == 9);
1450 1 : CATCH_REQUIRE(verbose_ref.length() == 4);
1451 1 : CATCH_REQUIRE(verbose_ref.size() == 4);
1452 :
1453 1 : SNAP_CATCH2_NAMESPACE::push_expected_log("error: invalid default value for a number (undefined) in parameter --reference at offset 0.");
1454 1 : CATCH_REQUIRE(reference_ref.get_long() == -1);
1455 1 : SNAP_CATCH2_NAMESPACE::expected_logs_stack_is_empty();
1456 :
1457 1 : CATCH_REQUIRE(reference_ref == reference_ref);
1458 1 : CATCH_REQUIRE_FALSE(reference_ref != reference_ref);
1459 1 : CATCH_REQUIRE_FALSE(reference_ref < reference_ref);
1460 1 : CATCH_REQUIRE(reference_ref <= reference_ref);
1461 1 : CATCH_REQUIRE_FALSE(reference_ref > reference_ref);
1462 1 : CATCH_REQUIRE(reference_ref >= reference_ref);
1463 :
1464 1 : CATCH_REQUIRE_FALSE(reference_ref == verbose_ref);
1465 1 : CATCH_REQUIRE(reference_ref != verbose_ref);
1466 1 : CATCH_REQUIRE_FALSE(reference_ref < verbose_ref);
1467 1 : CATCH_REQUIRE_FALSE(reference_ref <= verbose_ref);
1468 1 : CATCH_REQUIRE(reference_ref > verbose_ref);
1469 1 : CATCH_REQUIRE(reference_ref >= verbose_ref);
1470 : }
1471 : CATCH_END_SECTION()
1472 7 : }
1473 :
1474 :
1475 :
1476 :
1477 :
1478 :
1479 :
1480 : // vim: ts=4 sw=4 et
|
