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