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