LCOV - code coverage report
Current view: top level - tests - catch_data.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1792 1792 100.0 %
Date: 2022-03-01 20:39:45 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Copyright (c) 2006-2022  Made to Order Software Corp.  All Rights Reserved
       2             : //
       3             : // https://snapwebsites.org/project/advgetopt
       4             : // contact@m2osw.com
       5             : //
       6             : // This program is free software; you can redistribute it and/or modify
       7             : // it under the terms of the GNU General Public License as published by
       8             : // the Free Software Foundation; either version 2 of the License, or
       9             : // (at your option) any later version.
      10             : //
      11             : // This program is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : //
      16             : // You should have received a copy of the GNU General Public License along
      17             : // with this program; if not, write to the Free Software Foundation, Inc.,
      18             : // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      19             : 
      20             : // self
      21             : //
      22             : #include    "catch_main.h"
      23             : 
      24             : 
      25             : // advgetopt lib
      26             : //
      27             : #include    <advgetopt/exception.h>
      28             : #include    <advgetopt/version.h>
      29             : 
      30             : 
      31             : // snapdev lib
      32             : //
      33             : #include    <snapdev/safe_setenv.h>
      34             : 
      35             : 
      36             : // booost lib
      37             : //
      38             : #include    <boost/preprocessor/stringize.hpp>
      39             : 
      40             : 
      41             : // C++ lib
      42             : //
      43             : #include    <fstream>
      44             : 
      45             : 
      46             : // last include
      47             : //
      48             : #include    <snapdev/poison.h>
      49             : 
      50             : 
      51             : 
      52             : 
      53             : 
      54           4 : CATCH_TEST_CASE("string_access", "[arguments][valid][getopt]")
      55             : {
      56           4 :     CATCH_START_SECTION("Verify a string in a long argument")
      57           1 :         advgetopt::option const options[] =
      58             :         {
      59             :             advgetopt::define_option(
      60             :                   advgetopt::Name("user-name")
      61             :                 , advgetopt::ShortName('u')
      62             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
      63             :                 , advgetopt::Help("check specified user.")
      64             :             ),
      65             :             advgetopt::end_options()
      66             :         };
      67             : 
      68           1 :         advgetopt::options_environment environment_options;
      69           1 :         environment_options.f_project_name = "unittest";
      70           1 :         environment_options.f_options = options;
      71           1 :         environment_options.f_help_header = "Usage: user name as a string";
      72             : 
      73           1 :         char const * cargv[] =
      74             :         {
      75             :             "/usr/bin/arguments",
      76             :             "--user-name",
      77             :             "alexis",
      78             :             nullptr
      79             :         };
      80           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
      81           1 :         char ** argv = const_cast<char **>(cargv);
      82             : 
      83           2 :         advgetopt::getopt opt(environment_options, argc, argv);
      84             : 
      85             :         // check that the result is valid
      86             : 
      87             :         // an invalid parameter, MUST NOT EXIST
      88           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
      89           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
      90           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
      91           1 :         CATCH_REQUIRE_FALSE(opt.has_default("invalid-parameter"));
      92           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
      93           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
      94             : 
      95             :         // no default
      96           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
      97           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
      98           1 :         CATCH_REQUIRE_FALSE(opt.has_default("--"));
      99           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     100           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     101             : 
     102             :         // the valid parameter
     103           1 :         CATCH_REQUIRE(opt.get_option("user-name") != nullptr);
     104           1 :         CATCH_REQUIRE(opt.get_option('u') != nullptr);
     105           1 :         CATCH_REQUIRE(opt.get_string("user-name") == "alexis");
     106           1 :         CATCH_REQUIRE(opt.get_string("user-name", 0) == "alexis");
     107           1 :         CATCH_REQUIRE(opt["user-name"] == "alexis");
     108           1 :         CATCH_REQUIRE(opt.is_defined("user-name"));
     109           1 :         CATCH_REQUIRE_FALSE(opt.has_default("user-name"));
     110           1 :         CATCH_REQUIRE(opt.get_default("user-name").empty());
     111           1 :         CATCH_REQUIRE(opt.size("user-name") == 1);
     112             : 
     113             :         // other parameters
     114           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     115           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     116             :     CATCH_END_SECTION()
     117             : 
     118           4 :     CATCH_START_SECTION("Verify a string in a short argument")
     119           1 :         advgetopt::option const options[] =
     120             :         {
     121             :             advgetopt::define_option(
     122             :                   advgetopt::Name("user-name")
     123             :                 , advgetopt::ShortName('u')
     124             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     125             :                 , advgetopt::Help("check specified user.")
     126             :             ),
     127             :             advgetopt::end_options()
     128             :         };
     129             : 
     130           1 :         advgetopt::options_environment environment_options;
     131           1 :         environment_options.f_project_name = "unittest";
     132           1 :         environment_options.f_options = options;
     133           1 :         environment_options.f_help_header = "Usage: user name as a string";
     134             : 
     135           1 :         char const * cargv[] =
     136             :         {
     137             :             "/usr/bin/arguments",
     138             :             "-u",
     139             :             "alexis",
     140             :             nullptr
     141             :         };
     142           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     143           1 :         char ** argv = const_cast<char **>(cargv);
     144             : 
     145           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     146             : 
     147             :         // check that the result is valid
     148             : 
     149             :         // an invalid parameter, MUST NOT EXIST
     150           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     151           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     152           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     153           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     154           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     155             : 
     156             :         // no default
     157           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     158           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     159           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     160           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     161             : 
     162             :         // the valid parameter
     163           1 :         CATCH_REQUIRE(opt.get_option("user-name") != nullptr);
     164           1 :         CATCH_REQUIRE(opt.get_option('u') != nullptr);
     165           1 :         CATCH_REQUIRE(opt.get_string("user-name") == "alexis");
     166           1 :         CATCH_REQUIRE(opt.get_string("user-name", 0) == "alexis");
     167           1 :         CATCH_REQUIRE(opt["user-name"] == "alexis");
     168           1 :         CATCH_REQUIRE(opt.is_defined("user-name"));
     169           1 :         CATCH_REQUIRE(opt.get_default("user-name").empty());
     170           1 :         CATCH_REQUIRE(opt.size("user-name") == 1);
     171             : 
     172             :         // other parameters
     173           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     174           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     175             :     CATCH_END_SECTION()
     176           2 : }
     177             : 
     178             : 
     179           5 : CATCH_TEST_CASE("long_access", "[arguments][valid][getopt]")
     180             : {
     181           6 :     CATCH_START_SECTION("Verify an integer (long) value in a long argument")
     182           1 :         long const default_value(rand());
     183           2 :         std::string const default_value_str(std::to_string(default_value));
     184           1 :         char const * const default_val(default_value_str.c_str());
     185             : 
     186           1 :         advgetopt::option const options[] =
     187             :         {
     188             :             advgetopt::define_option(
     189             :                   advgetopt::Name("size")
     190             :                 , advgetopt::ShortName('s')
     191             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     192             :                 , advgetopt::Help("define the size.")
     193             :                 , advgetopt::DefaultValue(default_val)
     194           6 :             ),
     195             :             advgetopt::end_options()
     196           7 :         };
     197             : 
     198           1 :         advgetopt::options_environment environment_options;
     199           1 :         environment_options.f_project_name = "unittest";
     200           1 :         environment_options.f_options = options;
     201           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
     202             : 
     203           1 :         char const * cargv[] =
     204             :         {
     205             :             "/usr/bin/arguments",
     206             :             "--size",
     207             :             "9821",
     208             :             nullptr
     209             :         };
     210           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     211           1 :         char ** argv = const_cast<char **>(cargv);
     212             : 
     213           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     214             : 
     215             :         // check that the result is valid
     216             : 
     217             :         // an invalid parameter, MUST NOT EXIST
     218           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     219           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     220           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     221           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     222           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     223             : 
     224             :         // no default
     225           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     226           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     227           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     228           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     229             : 
     230             :         // the valid parameter
     231           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     232           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
     233           1 :         CATCH_REQUIRE(opt.is_defined("size"));
     234           1 :         CATCH_REQUIRE(opt.get_string("size") == "9821");
     235           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "9821");
     236           1 :         CATCH_REQUIRE(opt["size"] == "9821");
     237           1 :         CATCH_REQUIRE(opt.get_long("size") == 9821);
     238           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 9821);
     239           1 :         CATCH_REQUIRE(opt.has_default("size"));
     240           1 :         CATCH_REQUIRE(opt.get_default("size") == default_value_str);
     241           1 :         CATCH_REQUIRE(opt.size("size") == 1);
     242             : 
     243             :         // other parameters
     244           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     245           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     246             :     CATCH_END_SECTION()
     247             : 
     248           6 :     CATCH_START_SECTION("Verify an integer (long) value in a short argument")
     249           1 :         advgetopt::option const options[] =
     250             :         {
     251             :             advgetopt::define_option(
     252             :                   advgetopt::Name("size")
     253             :                 , advgetopt::ShortName('s')
     254             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     255             :                 , advgetopt::Help("define the size.")
     256             :                 , advgetopt::DefaultValue("")
     257             :             ),
     258             :             advgetopt::end_options()
     259             :         };
     260             : 
     261           1 :         advgetopt::options_environment environment_options;
     262           1 :         environment_options.f_project_name = "unittest";
     263           1 :         environment_options.f_options = options;
     264           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
     265             : 
     266           1 :         char const * cargv[] =
     267             :         {
     268             :             "/usr/bin/arguments",
     269             :             "-s",
     270             :             "9821",
     271             :             nullptr
     272             :         };
     273           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     274           1 :         char ** argv = const_cast<char **>(cargv);
     275             : 
     276           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     277             : 
     278             :         // check that the result is valid
     279             : 
     280             :         // an invalid parameter, MUST NOT EXIST
     281           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     282           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     283           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     284           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     285           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     286             : 
     287             :         // to reach the constant version `opt` has to be constant
     288           2 :         std::string const array_syntax_invalid_parameter(static_cast<advgetopt::getopt const &>(opt)["invalid-parameter"]);
     289           1 :         CATCH_REQUIRE(array_syntax_invalid_parameter == std::string());
     290             : 
     291             :         // no default
     292           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     293           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     294           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     295           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     296             : 
     297             :         // the valid parameter
     298           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     299           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
     300           1 :         CATCH_REQUIRE(opt.is_defined("size"));
     301           1 :         CATCH_REQUIRE(opt.get_string("size") == "9821");
     302           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "9821");
     303           1 :         CATCH_REQUIRE(opt["size"] == "9821");
     304           1 :         CATCH_REQUIRE(opt.get_long("size") == 9821);
     305           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 9821);
     306           1 :         CATCH_REQUIRE(opt.has_default("size"));
     307           1 :         CATCH_REQUIRE(opt.get_default("size").empty());
     308           1 :         CATCH_REQUIRE(opt.size("size") == 1);
     309             : 
     310             :         // to access the constant reference we need a constant `opt`...
     311           2 :         std::string const array_syntax1(static_cast<advgetopt::getopt const &>(opt)["size"]);
     312           1 :         CATCH_REQUIRE(array_syntax1 == "9821");
     313           1 :         bool const array_syntax2(static_cast<advgetopt::getopt const &>(opt)["size"] == std::string("9821"));
     314           1 :         CATCH_REQUIRE(array_syntax2);
     315             : 
     316             :         // other parameters
     317           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     318           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     319             :     CATCH_END_SECTION()
     320             : 
     321           6 :     CATCH_START_SECTION("Verify an integer (long) value in no arguments")
     322           1 :         advgetopt::option const options[] =
     323             :         {
     324             :             advgetopt::define_option(
     325             :                   advgetopt::Name("size")
     326             :                 , advgetopt::ShortName('s')
     327             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     328             :                 , advgetopt::Help("define the size.")
     329             :                 , advgetopt::DefaultValue("839")
     330             :             ),
     331             :             advgetopt::end_options()
     332             :         };
     333             : 
     334           1 :         advgetopt::options_environment environment_options;
     335           1 :         environment_options.f_project_name = "unittest";
     336           1 :         environment_options.f_options = options;
     337           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
     338             : 
     339           1 :         char const * cargv[] =
     340             :         {
     341             :             "/usr/bin/arguments",
     342             :             nullptr
     343             :         };
     344           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     345           1 :         char ** argv = const_cast<char **>(cargv);
     346             : 
     347           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     348             : 
     349             :         // check that the result is valid
     350             : 
     351             :         // an invalid parameter, MUST NOT EXIST
     352           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     353           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     354           1 :         CATCH_REQUIRE(opt["invalid-parameter"] == std::string());
     355           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     356           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     357           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     358             : 
     359             :         // no default
     360           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     361           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     362           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     363           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     364             : 
     365             :         // the valid parameter
     366           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     367           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
     368           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
     369           1 :         CATCH_REQUIRE(opt.get_string("size") == "839");
     370           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "839");
     371           1 :         CATCH_REQUIRE(opt.get_long("size") == 839);
     372           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 839);
     373           1 :         CATCH_REQUIRE(opt.has_default("size"));
     374           1 :         CATCH_REQUIRE(opt.get_default("size") == "839");
     375           1 :         CATCH_REQUIRE(opt.size("size") == 0);
     376             : 
     377             :         // with a constant opt, the array syntax returns the default string
     378           1 :         CATCH_REQUIRE(static_cast<advgetopt::getopt const &>(opt)["size"] == "839");
     379             : 
     380             :         // other parameters
     381           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     382           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     383             :     CATCH_END_SECTION()
     384           3 : }
     385             : 
     386             : 
     387             : 
     388           4 : CATCH_TEST_CASE("system_flags_version", "[arguments][valid][getopt][system_flags]")
     389             : {
     390           4 :     CATCH_START_SECTION("Check with the --version system flag")
     391             :     {
     392           1 :         long const major_version(rand());
     393           1 :         long const minor_version(rand());
     394           1 :         long const patch_version(rand());
     395           1 :         long const build_version(rand());
     396           3 :         std::string const version(std::to_string(major_version)
     397           3 :                                 + "."
     398           4 :                                 + std::to_string(minor_version)
     399           3 :                                 + "."
     400           4 :                                 + std::to_string(patch_version)
     401           3 :                                 + "."
     402           4 :                                 + std::to_string(build_version));
     403             : 
     404           1 :         long const default_value(rand());
     405           2 :         std::string const default_val(std::to_string(default_value));
     406           1 :         advgetopt::option const options[] =
     407             :         {
     408             :             advgetopt::define_option(
     409             :                   advgetopt::Name("size")
     410             :                 , advgetopt::ShortName('s')
     411             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     412             :                 , advgetopt::Help("define the size.")
     413             :                 , advgetopt::DefaultValue(default_val.c_str())
     414           6 :             ),
     415             :             advgetopt::end_options()
     416           7 :         };
     417             : 
     418           1 :         advgetopt::options_environment environment_options;
     419           1 :         environment_options.f_project_name = "unittest";
     420           1 :         environment_options.f_options = options;
     421           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     422           1 :         environment_options.f_help_header = "Usage: test system commands";
     423           1 :         environment_options.f_version = version.c_str();
     424             : 
     425           1 :         char const * cargv[] =
     426             :         {
     427             :             "/usr/bin/arguments",
     428             :             "--version",
     429             :             nullptr
     430             :         };
     431           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     432           1 :         char ** argv = const_cast<char **>(cargv);
     433             : 
     434           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     435             : 
     436             :         // check that the result is valid
     437             : 
     438             :         // an invalid parameter, MUST NOT EXIST
     439           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     440           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     441           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     442           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     443           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     444             : 
     445             :         // no default
     446           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     447           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     448           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     449           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     450             : 
     451             :         // valid parameter
     452           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     453           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     454           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
     455           1 :         CATCH_REQUIRE(opt.get_string("size") == default_val);
     456           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == default_val);
     457           1 :         CATCH_REQUIRE(opt["size"] == default_val);
     458           1 :         CATCH_REQUIRE(opt.get_long("size") == default_value);
     459           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == default_value);
     460           1 :         CATCH_REQUIRE(opt.has_default("size"));
     461           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     462           1 :         CATCH_REQUIRE(opt.size("size") == 0);
     463             : 
     464             :         // version parameter
     465           1 :         CATCH_REQUIRE(opt.get_option("version") != nullptr);
     466           1 :         CATCH_REQUIRE(opt.get_option('V') == opt.get_option("version"));
     467           1 :         CATCH_REQUIRE(opt.is_defined("version"));
     468           1 :         CATCH_REQUIRE(opt.get_string("version") == "");
     469           1 :         CATCH_REQUIRE(opt.get_string("version", 0) == "");
     470           1 :         CATCH_REQUIRE(opt["version"] == "");
     471           1 :         CATCH_REQUIRE_FALSE(opt.has_default("version"));
     472           1 :         CATCH_REQUIRE(opt.get_default("version").empty());
     473           1 :         CATCH_REQUIRE(opt.size("version") == 1);
     474             : 
     475             :         // other parameters
     476           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     477           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     478             : 
     479             :         // process system options now
     480           2 :         std::stringstream ss;
     481           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     482           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_VERSION);
     483           1 :         CATCH_REQUIRE(ss.str() == version + '\n');
     484             :     }
     485             :     CATCH_END_SECTION()
     486             : 
     487           4 :     CATCH_START_SECTION("Check with the --version system flag, without a --version on the command line")
     488             :     {
     489           1 :         long const major_version(rand());
     490           1 :         long const minor_version(rand());
     491           1 :         long const patch_version(rand());
     492           1 :         long const build_version(rand());
     493           3 :         std::string const version(std::to_string(major_version)
     494           3 :                                 + "."
     495           4 :                                 + std::to_string(minor_version)
     496           3 :                                 + "."
     497           4 :                                 + std::to_string(patch_version)
     498           3 :                                 + "."
     499           4 :                                 + std::to_string(build_version));
     500             : 
     501           1 :         long const default_value(rand());
     502           2 :         std::string const default_val(std::to_string(default_value));
     503           1 :         advgetopt::option const options[] =
     504             :         {
     505             :             advgetopt::define_option(
     506             :                   advgetopt::Name("size")
     507             :                 , advgetopt::ShortName('s')
     508             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     509             :                 , advgetopt::Help("define the size.")
     510             :                 , advgetopt::DefaultValue(default_val.c_str())
     511           6 :             ),
     512             :             advgetopt::end_options()
     513           7 :         };
     514             : 
     515           1 :         advgetopt::options_environment environment_options;
     516           1 :         environment_options.f_project_name = "unittest";
     517           1 :         environment_options.f_options = options;
     518           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     519           1 :         environment_options.f_help_header = "Usage: test system commands";
     520           1 :         environment_options.f_version = version.c_str();
     521             : 
     522           1 :         char const * cargv[] =
     523             :         {
     524             :             "/usr/bin/arguments",
     525             :             "--size",
     526             :             "1221",
     527             :             nullptr
     528             :         };
     529           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     530           1 :         char ** argv = const_cast<char **>(cargv);
     531             : 
     532           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     533             : 
     534             :         // check that the result is valid
     535             : 
     536             :         // an invalid parameter, MUST NOT EXIST
     537           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     538           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     539           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     540           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     541           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     542             : 
     543             :         // no default
     544           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     545           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     546           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     547           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     548             : 
     549             :         // valid parameter
     550           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     551           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     552           1 :         CATCH_REQUIRE(opt.is_defined("size"));
     553           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
     554           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
     555           1 :         CATCH_REQUIRE(opt["size"] == "1221");
     556           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
     557           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
     558           1 :         CATCH_REQUIRE(opt.has_default("size"));
     559           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     560           1 :         CATCH_REQUIRE(opt.size("size") == 1);
     561             : 
     562             :         // version parameter
     563           1 :         CATCH_REQUIRE(opt.get_option("version") != nullptr);
     564           1 :         CATCH_REQUIRE(opt.get_option('V') == opt.get_option("version"));
     565           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("version"));
     566           1 :         CATCH_REQUIRE_FALSE(opt.has_default("version"));
     567           1 :         CATCH_REQUIRE(opt.get_default("version").empty());
     568           1 :         CATCH_REQUIRE(opt.size("version") == 0);
     569             : 
     570             :         // other parameters
     571           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     572           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     573             : 
     574             :         // process system options now
     575           2 :         std::stringstream ss;
     576           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     577           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
     578           1 :         CATCH_REQUIRE(ss.str().empty());
     579             :     }
     580             :     CATCH_END_SECTION()
     581           2 : }
     582             : 
     583             : 
     584             : 
     585           4 : CATCH_TEST_CASE("system_flags_has_sanitizer", "[arguments][valid][getopt][system_flags]")
     586             : {
     587           4 :     CATCH_START_SECTION("Check with the --has-sanitizer system flag")
     588             :     {
     589           1 :         long const default_value(rand());
     590           2 :         std::string const default_val(std::to_string(default_value));
     591           1 :         advgetopt::option const options[] =
     592             :         {
     593             :             advgetopt::define_option(
     594             :                   advgetopt::Name("size")
     595             :                 , advgetopt::ShortName('s')
     596             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     597             :                 , advgetopt::Help("define the size.")
     598             :                 , advgetopt::DefaultValue(default_val.c_str())
     599           6 :             ),
     600             :             advgetopt::end_options()
     601           7 :         };
     602             : 
     603           1 :         advgetopt::options_environment environment_options;
     604           1 :         environment_options.f_project_name = "unittest";
     605           1 :         environment_options.f_options = options;
     606           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     607           1 :         environment_options.f_help_header = "Usage: test system commands";
     608           1 :         environment_options.f_version = "2.0.24.0";
     609             : 
     610           1 :         char const * cargv[] =
     611             :         {
     612             :             "/usr/bin/arguments",
     613             :             "--has-sanitizer",
     614             :             nullptr
     615             :         };
     616           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     617           1 :         char ** argv = const_cast<char **>(cargv);
     618             : 
     619           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     620             : 
     621             :         // check that the result is valid
     622             : 
     623             :         // an invalid parameter, MUST NOT EXIST
     624           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     625           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     626           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     627           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     628           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     629             : 
     630             :         // no default
     631           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     632           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     633           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     634           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     635             : 
     636             :         // valid parameter
     637           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     638           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     639           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
     640           1 :         CATCH_REQUIRE(opt.get_string("size") == default_val);
     641           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == default_val);
     642           1 :         CATCH_REQUIRE(opt["size"] == default_val);
     643           1 :         CATCH_REQUIRE(opt.get_long("size") == default_value);
     644           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == default_value);
     645           1 :         CATCH_REQUIRE(opt.has_default("size"));
     646           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     647           1 :         CATCH_REQUIRE(opt.size("size") == 0);
     648             : 
     649             :         // has-sanitizer parameter
     650           1 :         CATCH_REQUIRE(opt.get_option("has-sanitizer") != nullptr);
     651           1 :         CATCH_REQUIRE(opt.is_defined("has-sanitizer"));
     652           1 :         CATCH_REQUIRE(opt.get_string("has-sanitizer") == "");
     653           1 :         CATCH_REQUIRE(opt.get_string("has-sanitizer", 0) == "");
     654           1 :         CATCH_REQUIRE(opt["has-sanitizer"] == "");
     655           1 :         CATCH_REQUIRE_FALSE(opt.has_default("has-sanitizer"));
     656           1 :         CATCH_REQUIRE(opt.get_default("has-sanitizer").empty());
     657           1 :         CATCH_REQUIRE(opt.size("has-sanitizer") == 1);
     658             : 
     659             :         // other parameters
     660           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     661           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     662             : 
     663             :         // process system options now
     664           2 :         std::stringstream ss;
     665           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     666           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
     667             : #if defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__)
     668             :         // when running coverage or in the Sanitize version
     669             :         //
     670           1 :         std::string const expected(
     671             : #ifdef __SANITIZE_ADDRESS__
     672             :                 "The address sanitizer is compiled in.\n"
     673             : #endif
     674             : #ifdef __SANITIZE_THREAD__
     675             :                 "The thread sanitizer is compiled in.\n"
     676             : #endif
     677           2 :             );
     678           1 :         CATCH_REQUIRE(ss.str() == expected);
     679             : #else
     680             :         // when running in Debug or Release
     681             :         //
     682             :         CATCH_REQUIRE(ss.str() == "The address and thread sanitizers are not compiled in.\n");
     683             : #endif
     684             :     }
     685             :     CATCH_END_SECTION()
     686             : 
     687           4 :     CATCH_START_SECTION("Check with the --has-sanitizer system flag, without a --has-sanitizer on the command line")
     688             :     {
     689           1 :         long const default_value(rand());
     690           2 :         std::string const default_val(std::to_string(default_value));
     691           1 :         advgetopt::option const options[] =
     692             :         {
     693             :             advgetopt::define_option(
     694             :                   advgetopt::Name("size")
     695             :                 , advgetopt::ShortName('s')
     696             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     697             :                 , advgetopt::Help("define the size.")
     698             :                 , advgetopt::DefaultValue(default_val.c_str())
     699           6 :             ),
     700             :             advgetopt::end_options()
     701           7 :         };
     702             : 
     703           1 :         advgetopt::options_environment environment_options;
     704           1 :         environment_options.f_project_name = "unittest";
     705           1 :         environment_options.f_options = options;
     706           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     707           1 :         environment_options.f_help_header = "Usage: test system commands";
     708           1 :         environment_options.f_version = "2.0.24.1";
     709             : 
     710           1 :         char const * cargv[] =
     711             :         {
     712             :             "/usr/bin/arguments",
     713             :             "--size",
     714             :             "1221",
     715             :             nullptr
     716             :         };
     717           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     718           1 :         char ** argv = const_cast<char **>(cargv);
     719             : 
     720           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     721             : 
     722             :         // check that the result is valid
     723             : 
     724             :         // an invalid parameter, MUST NOT EXIST
     725           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     726           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     727           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     728           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     729           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     730             : 
     731             :         // no default
     732           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     733           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     734           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     735           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     736             : 
     737             :         // valid parameter
     738           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     739           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     740           1 :         CATCH_REQUIRE(opt.is_defined("size"));
     741           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
     742           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
     743           1 :         CATCH_REQUIRE(opt["size"] == "1221");
     744           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
     745           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
     746           1 :         CATCH_REQUIRE(opt.has_default("size"));
     747           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     748           1 :         CATCH_REQUIRE(opt.size("size") == 1);
     749             : 
     750             :         // has-sanitizer parameter
     751           1 :         CATCH_REQUIRE(opt.get_option("has-sanitizer") != nullptr);
     752           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("has-sanitizer"));
     753           1 :         CATCH_REQUIRE_FALSE(opt.has_default("has-sanitizer"));
     754           1 :         CATCH_REQUIRE(opt.get_default("has-sanitizer").empty());
     755           1 :         CATCH_REQUIRE(opt.size("has-sanitizer") == 0);
     756             : 
     757             :         // other parameters
     758           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     759           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     760             : 
     761             :         // process system options now
     762           2 :         std::stringstream ss;
     763           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     764           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
     765           1 :         CATCH_REQUIRE(ss.str().empty());
     766             :     }
     767             :     CATCH_END_SECTION()
     768           2 : }
     769             : 
     770             : 
     771             : 
     772           4 : CATCH_TEST_CASE("system_flags_compiler_version", "[arguments][valid][getopt][system_flags]")
     773             : {
     774           4 :     CATCH_START_SECTION("Check with the --compiler-version system flag")
     775             :     {
     776           1 :         long const default_value(rand());
     777           2 :         std::string const default_val(std::to_string(default_value));
     778           1 :         advgetopt::option const options[] =
     779             :         {
     780             :             advgetopt::define_option(
     781             :                   advgetopt::Name("size")
     782             :                 , advgetopt::ShortName('s')
     783             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     784             :                 , advgetopt::Help("define the size.")
     785             :                 , advgetopt::DefaultValue(default_val.c_str())
     786           6 :             ),
     787             :             advgetopt::end_options()
     788           7 :         };
     789             : 
     790           1 :         advgetopt::options_environment environment_options;
     791           1 :         environment_options.f_project_name = "unittest";
     792           1 :         environment_options.f_options = options;
     793           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     794           1 :         environment_options.f_help_header = "Usage: test system commands";
     795           1 :         environment_options.f_version = "2.0.24.0";
     796             : 
     797           1 :         char const * cargv[] =
     798             :         {
     799             :             "/usr/bin/arguments",
     800             :             "--compiler-version",
     801             :             nullptr
     802             :         };
     803           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     804           1 :         char ** argv = const_cast<char **>(cargv);
     805             : 
     806           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     807             : 
     808             :         // check that the result is valid
     809             : 
     810             :         // an invalid parameter, MUST NOT EXIST
     811           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     812           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     813           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     814           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     815           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     816             : 
     817             :         // no default
     818           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     819           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     820           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     821           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     822             : 
     823             :         // valid parameter
     824           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     825           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     826           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
     827           1 :         CATCH_REQUIRE(opt.get_string("size") == default_val);
     828           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == default_val);
     829           1 :         CATCH_REQUIRE(opt["size"] == default_val);
     830           1 :         CATCH_REQUIRE(opt.get_long("size") == default_value);
     831           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == default_value);
     832           1 :         CATCH_REQUIRE(opt.has_default("size"));
     833           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     834           1 :         CATCH_REQUIRE(opt.size("size") == 0);
     835             : 
     836             :         // compiler-version parameter
     837           1 :         CATCH_REQUIRE(opt.get_option("compiler-version") != nullptr);
     838           1 :         CATCH_REQUIRE(opt.is_defined("compiler-version"));
     839           1 :         CATCH_REQUIRE(opt.get_string("compiler-version") == "");
     840           1 :         CATCH_REQUIRE(opt.get_string("compiler-version", 0) == "");
     841           1 :         CATCH_REQUIRE(opt["compiler-version"] == "");
     842           1 :         CATCH_REQUIRE_FALSE(opt.has_default("compiler-version"));
     843           1 :         CATCH_REQUIRE(opt.get_default("compiler-version").empty());
     844           1 :         CATCH_REQUIRE(opt.size("compiler-version") == 1);
     845             : 
     846             :         // other parameters
     847           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     848           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     849             : 
     850             :         // process system options now
     851           2 :         std::stringstream ss;
     852           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     853           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
     854           1 :         CATCH_REQUIRE(ss.str() == LIBADVGETOPT_COMPILER_VERSION "\n");
     855             :     }
     856             :     CATCH_END_SECTION()
     857             : 
     858           4 :     CATCH_START_SECTION("Check with the --compiler-version system flag, without a --compiler-version on the command line")
     859             :     {
     860           1 :         long const default_value(rand());
     861           2 :         std::string const default_val(std::to_string(default_value));
     862           1 :         advgetopt::option const options[] =
     863             :         {
     864             :             advgetopt::define_option(
     865             :                   advgetopt::Name("size")
     866             :                 , advgetopt::ShortName('s')
     867             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     868             :                 , advgetopt::Help("define the size.")
     869             :                 , advgetopt::DefaultValue(default_val.c_str())
     870           6 :             ),
     871             :             advgetopt::end_options()
     872           7 :         };
     873             : 
     874           1 :         advgetopt::options_environment environment_options;
     875           1 :         environment_options.f_project_name = "unittest";
     876           1 :         environment_options.f_options = options;
     877           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     878           1 :         environment_options.f_help_header = "Usage: test system commands";
     879           1 :         environment_options.f_version = "2.0.24.1";
     880             : 
     881           1 :         char const * cargv[] =
     882             :         {
     883             :             "/usr/bin/arguments",
     884             :             "--size",
     885             :             "1221",
     886             :             nullptr
     887             :         };
     888           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     889           1 :         char ** argv = const_cast<char **>(cargv);
     890             : 
     891           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     892             : 
     893             :         // check that the result is valid
     894             : 
     895             :         // an invalid parameter, MUST NOT EXIST
     896           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
     897           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
     898           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
     899           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
     900           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
     901             : 
     902             :         // no default
     903           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
     904           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
     905           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
     906           1 :         CATCH_REQUIRE(opt.size("--") == 0);
     907             : 
     908             :         // valid parameter
     909           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
     910           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
     911           1 :         CATCH_REQUIRE(opt.is_defined("size"));
     912           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
     913           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
     914           1 :         CATCH_REQUIRE(opt["size"] == "1221");
     915           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
     916           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
     917           1 :         CATCH_REQUIRE(opt.has_default("size"));
     918           1 :         CATCH_REQUIRE(opt.get_default("size") == default_val);
     919           1 :         CATCH_REQUIRE(opt.size("size") == 1);
     920             : 
     921             :         // compiler-version parameter
     922           1 :         CATCH_REQUIRE(opt.get_option("compiler-version") != nullptr);
     923           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("compiler-version"));
     924           1 :         CATCH_REQUIRE_FALSE(opt.has_default("compiler-version"));
     925           1 :         CATCH_REQUIRE(opt.get_default("compiler-version").empty());
     926           1 :         CATCH_REQUIRE(opt.size("compiler-version") == 0);
     927             : 
     928             :         // other parameters
     929           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
     930           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
     931             : 
     932             :         // process system options now
     933           2 :         std::stringstream ss;
     934           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
     935           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
     936           1 :         CATCH_REQUIRE(ss.str().empty());
     937             :     }
     938             :     CATCH_END_SECTION()
     939           2 : }
     940             : 
     941             : 
     942             : 
     943           7 : CATCH_TEST_CASE("system_flags_help", "[arguments][valid][getopt][system_flags]")
     944             : {
     945          10 :     CATCH_START_SECTION("Check with the --help system flag")
     946             :     {
     947           1 :         advgetopt::option const options[] =
     948             :         {
     949             :             advgetopt::define_option(
     950             :                   advgetopt::Name("size")
     951             :                 , advgetopt::ShortName('s')
     952             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
     953             :                 , advgetopt::Help("define the size.")
     954             :                 , advgetopt::DefaultValue("33")
     955             :             ),
     956             :             advgetopt::define_option(
     957             :                   advgetopt::Name("obscure")
     958             :                 , advgetopt::ShortName('o')
     959             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
     960             :                                                           , advgetopt::GETOPT_FLAG_SHOW_GROUP1>())
     961             :                 , advgetopt::Help("obscure command, hidden by default.")
     962             :             ),
     963             :             advgetopt::define_option(
     964             :                   advgetopt::Name("secret")
     965             :                 , advgetopt::ShortName('S')
     966             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
     967             :                                                           , advgetopt::GETOPT_FLAG_SHOW_GROUP2>())
     968             :                 , advgetopt::Help("even more secret command, hidden by default.")
     969             :             ),
     970             :             advgetopt::end_options()
     971             :         };
     972             : 
     973           1 :         advgetopt::options_environment environment_options;
     974           1 :         environment_options.f_project_name = "unittest";
     975           1 :         environment_options.f_options = options;
     976           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
     977           1 :         environment_options.f_help_header = "Usage: test system commands";
     978           1 :         environment_options.f_help_footer = "Copyright matters";
     979             : 
     980           1 :         char const * cargv[] =
     981             :         {
     982             :             "/usr/bin/arguments",
     983             :             "--help",
     984             :             nullptr
     985             :         };
     986           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
     987           1 :         char ** argv = const_cast<char **>(cargv);
     988             : 
     989           2 :         advgetopt::getopt opt(environment_options, argc, argv);
     990             : 
     991             :         // check that the result is valid
     992             : 
     993             :         // check the list of options
     994           1 :         advgetopt::option_info::map_by_name_t const & list_of_options(opt.get_options());
     995           1 :         CATCH_REQUIRE(list_of_options.size() == 3 + 11 + 1);
     996             : 
     997             :         // user options
     998           1 :         CATCH_REQUIRE(list_of_options.find("size") != list_of_options.end());
     999           1 :         CATCH_REQUIRE(list_of_options.find("obscure") != list_of_options.end());
    1000           1 :         CATCH_REQUIRE(list_of_options.find("secret") != list_of_options.end());
    1001             : 
    1002             :         // system options
    1003           1 :         CATCH_REQUIRE(list_of_options.find("help") != list_of_options.end());
    1004           1 :         CATCH_REQUIRE(list_of_options.find("long-help") != list_of_options.end());
    1005           1 :         CATCH_REQUIRE(list_of_options.find("version") != list_of_options.end());
    1006           1 :         CATCH_REQUIRE(list_of_options.find("copyright") != list_of_options.end());
    1007           1 :         CATCH_REQUIRE(list_of_options.find("license") != list_of_options.end());
    1008           1 :         CATCH_REQUIRE(list_of_options.find("build-date") != list_of_options.end());
    1009           1 :         CATCH_REQUIRE(list_of_options.find("environment-variable-name") != list_of_options.end());
    1010           1 :         CATCH_REQUIRE(list_of_options.find("configuration-filenames") != list_of_options.end());
    1011           1 :         CATCH_REQUIRE(list_of_options.find("path-to-option-definitions") != list_of_options.end());
    1012             : 
    1013             :         // an invalid parameter, MUST NOT EXIST
    1014           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1015           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1016           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1017           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1018           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1019             : 
    1020             :         // no default
    1021           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1022           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1023           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1024           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1025             : 
    1026             :         // valid parameter
    1027           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1028           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1029           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1030           1 :         CATCH_REQUIRE(opt.get_string("size") == "33");
    1031           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "33");
    1032           1 :         CATCH_REQUIRE(opt["size"] == "33");
    1033           1 :         CATCH_REQUIRE(opt.get_long("size") == 33);
    1034           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 33);
    1035           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1036           1 :         CATCH_REQUIRE(opt.get_default("size") == "33");
    1037           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1038             : 
    1039             :         // help parameter
    1040           1 :         CATCH_REQUIRE(opt.get_option("help") != nullptr);
    1041           1 :         CATCH_REQUIRE(opt.get_option('h') == opt.get_option("help"));
    1042           1 :         CATCH_REQUIRE(opt.is_defined("help"));
    1043           1 :         CATCH_REQUIRE(opt.get_string("help") == "");
    1044           1 :         CATCH_REQUIRE(opt.get_string("help", 0) == "");
    1045           1 :         CATCH_REQUIRE(opt["help"] == "");
    1046           1 :         CATCH_REQUIRE_FALSE(opt.has_default("help"));
    1047           1 :         CATCH_REQUIRE(opt.get_default("help").empty());
    1048           1 :         CATCH_REQUIRE(opt.size("help") == 1);
    1049             : 
    1050             :         // other parameters
    1051           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1052           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1053             : 
    1054             :         // process system options now
    1055           2 :         std::stringstream ss;
    1056           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1057           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
    1058           1 :         CATCH_REQUIRE_LONG_STRING(ss.str(),
    1059             : advgetopt::getopt::breakup_line(
    1060             :               "Usage: test system commands"
    1061             :             , 0
    1062             :             , advgetopt::getopt::get_line_width())
    1063             : + advgetopt::getopt::format_usage_string(
    1064             :               "--build-date"
    1065             :             , "print out the time and date when arguments was built and exit."
    1066             :             , 30
    1067             :             , advgetopt::getopt::get_line_width())
    1068             : + advgetopt::getopt::format_usage_string(
    1069             :               "--compiler-version"
    1070             :             , "print the version of the compiler used to compile the advgetopt library."
    1071             :             , 30
    1072             :             , advgetopt::getopt::get_line_width())
    1073             : + advgetopt::getopt::format_usage_string(
    1074             :               "--configuration-filenames"
    1075             :             , "print out the list of configuration files checked out by this"
    1076             :               " tool."
    1077             :             , 30
    1078             :             , advgetopt::getopt::get_line_width())
    1079             : + advgetopt::getopt::format_usage_string(
    1080             :               "--copyright or -C"
    1081             :             , "print out the copyright of arguments and exit."
    1082             :             , 30
    1083             :             , advgetopt::getopt::get_line_width())
    1084             : + advgetopt::getopt::format_usage_string(
    1085             :               "--environment-variable-name"
    1086             :             , "print out the name of the environment variable supported by"
    1087             :               " arguments (if any.)"
    1088             :             , 30
    1089             :             , advgetopt::getopt::get_line_width())
    1090             : + advgetopt::getopt::format_usage_string(
    1091             :               "--has-sanitizer"
    1092             :             , "print whether the advgetopt was compiled with the sanitizer extension."
    1093             :             , 30
    1094             :             , advgetopt::getopt::get_line_width())
    1095             : + advgetopt::getopt::format_usage_string(
    1096             :               "--help or -h"
    1097             :             , "print out this help screen and exit."
    1098             :             , 30
    1099             :             , advgetopt::getopt::get_line_width())
    1100             : + advgetopt::getopt::format_usage_string(
    1101             :               "--license or -L"
    1102             :             , "print out the license of arguments and exit."
    1103             :             , 30
    1104             :             , advgetopt::getopt::get_line_width())
    1105             : + advgetopt::getopt::format_usage_string(
    1106             :               "--long-help or -?"
    1107             :             , "show all the help from all the available options."
    1108             :             , 30
    1109             :             , advgetopt::getopt::get_line_width())
    1110             : + advgetopt::getopt::format_usage_string(
    1111             :               "--path-to-option-definitions"
    1112             :             , "print out the path to the option definitions."
    1113             :             , 30
    1114             :             , advgetopt::getopt::get_line_width())
    1115             : + advgetopt::getopt::format_usage_string(
    1116             :               "--show-option-sources"
    1117             :             , "parse all the options and then print out the source of each"
    1118             :               " value and each override."
    1119             :             , 30
    1120             :             , advgetopt::getopt::get_line_width())
    1121             : + advgetopt::getopt::format_usage_string(
    1122             :               "--size or -s <arg> (default is \"33\")"
    1123             :             , "define the size."
    1124             :             , 30
    1125             :             , advgetopt::getopt::get_line_width())
    1126             : + advgetopt::getopt::format_usage_string(
    1127             :               "--version or -V"
    1128             :             , "print out the version of arguments and exit."
    1129             :             , 30
    1130             :             , advgetopt::getopt::get_line_width())
    1131             : + "\n"
    1132             :   "Copyright matters\n"
    1133             :   "\n"
    1134             :                     );
    1135             :     }
    1136             :     CATCH_END_SECTION()
    1137             : 
    1138          10 :     CATCH_START_SECTION("Check with the --long-help system flag")
    1139             :     {
    1140           1 :         advgetopt::option const options[] =
    1141             :         {
    1142             :             advgetopt::define_option(
    1143             :                   advgetopt::Name("size")
    1144             :                 , advgetopt::ShortName('s')
    1145             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1146             :                 , advgetopt::Help("define the size.")
    1147             :                 , advgetopt::DefaultValue("33")
    1148             :             ),
    1149             :             advgetopt::define_option(
    1150             :                   advgetopt::Name("obscure")
    1151             :                 , advgetopt::ShortName('o')
    1152             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1153             :                                                           , advgetopt::GETOPT_FLAG_SHOW_GROUP1>())
    1154             :                 , advgetopt::Help("obscure command, hidden by default.")
    1155             :             ),
    1156             :             advgetopt::define_option(
    1157             :                   advgetopt::Name("secret")
    1158             :                 , advgetopt::ShortName('S')
    1159             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1160             :                                                           , advgetopt::GETOPT_FLAG_SHOW_GROUP2>())
    1161             :                 , advgetopt::Help("even more secret command, hidden by default.")
    1162             :             ),
    1163             :             advgetopt::end_options()
    1164             :         };
    1165             : 
    1166           1 :         advgetopt::options_environment environment_options;
    1167           1 :         environment_options.f_project_name = "unittest";
    1168           1 :         environment_options.f_options = options;
    1169           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1170           1 :         environment_options.f_help_header = "Usage: test system commands";
    1171           1 :         environment_options.f_help_footer = "Copyright matters";
    1172             : 
    1173           1 :         char const * cargv[] =
    1174             :         {
    1175             :             "/usr/bin/arguments",
    1176             :             "--long-help",
    1177             :             nullptr
    1178             :         };
    1179           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1180           1 :         char ** argv = const_cast<char **>(cargv);
    1181             : 
    1182           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1183             : 
    1184           1 :         CATCH_REQUIRE(opt.get_group_name() == std::string());
    1185             : 
    1186             :         // check that the result is valid
    1187             : 
    1188             :         // an invalid parameter, MUST NOT EXIST
    1189           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1190           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1191           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1192           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1193           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1194             : 
    1195             :         // no default
    1196           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1197           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1198           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1199           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1200             : 
    1201             :         // valid parameter
    1202           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1203           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1204           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1205           1 :         CATCH_REQUIRE(opt.get_string("size") == "33");
    1206           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "33");
    1207           1 :         CATCH_REQUIRE(opt["size"] == "33");
    1208           1 :         CATCH_REQUIRE(opt.get_long("size") == 33);
    1209           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 33);
    1210           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1211           1 :         CATCH_REQUIRE(opt.get_default("size") == "33");
    1212           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1213             : 
    1214             :         // help parameter
    1215           1 :         CATCH_REQUIRE(opt.get_option("long-help") != nullptr);
    1216           1 :         CATCH_REQUIRE(opt.get_option('?') == opt.get_option("long-help"));
    1217           1 :         CATCH_REQUIRE(opt.is_defined("long-help"));
    1218           1 :         CATCH_REQUIRE(opt.get_string("long-help") == "");
    1219           1 :         CATCH_REQUIRE(opt.get_string("long-help", 0) == "");
    1220           1 :         CATCH_REQUIRE(opt["long-help"] == "");
    1221           1 :         CATCH_REQUIRE_FALSE(opt.has_default("long-help"));
    1222           1 :         CATCH_REQUIRE(opt.get_default("long-help").empty());
    1223           1 :         CATCH_REQUIRE(opt.size("long-help") == 1);
    1224             : 
    1225             :         // other parameters
    1226           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1227           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1228             : 
    1229             :         // process system options now
    1230           2 :         std::stringstream ss;
    1231           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1232           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
    1233           1 :         CATCH_REQUIRE_LONG_STRING(ss.str(),
    1234             : advgetopt::getopt::breakup_line(
    1235             :               "Usage: test system commands"
    1236             :             , 0
    1237             :             , advgetopt::getopt::get_line_width())
    1238             : + advgetopt::getopt::format_usage_string(
    1239             :               "--build-date"
    1240             :             , "print out the time and date when arguments was built and exit."
    1241             :             , 30
    1242             :             , advgetopt::getopt::get_line_width())
    1243             : + advgetopt::getopt::format_usage_string(
    1244             :               "--compiler-version"
    1245             :             , "print the version of the compiler used to compile the advgetopt library."
    1246             :             , 30
    1247             :             , advgetopt::getopt::get_line_width())
    1248             : + advgetopt::getopt::format_usage_string(
    1249             :               "--configuration-filenames"
    1250             :             , "print out the list of configuration files checked out by this"
    1251             :               " tool."
    1252             :             , 30
    1253             :             , advgetopt::getopt::get_line_width())
    1254             : + advgetopt::getopt::format_usage_string(
    1255             :               "--copyright or -C"
    1256             :             , "print out the copyright of arguments and exit."
    1257             :             , 30
    1258             :             , advgetopt::getopt::get_line_width())
    1259             : + advgetopt::getopt::format_usage_string(
    1260             :               "--environment-variable-name"
    1261             :             , "print out the name of the environment variable supported by"
    1262             :               " arguments (if any.)"
    1263             :             , 30
    1264             :             , advgetopt::getopt::get_line_width())
    1265             : + advgetopt::getopt::format_usage_string(
    1266             :               "--has-sanitizer"
    1267             :             , "print whether the advgetopt was compiled with the sanitizer extension."
    1268             :             , 30
    1269             :             , advgetopt::getopt::get_line_width())
    1270             : + advgetopt::getopt::format_usage_string(
    1271             :               "--help or -h"
    1272             :             , "print out this help screen and exit."
    1273             :             , 30
    1274             :             , advgetopt::getopt::get_line_width())
    1275             : + advgetopt::getopt::format_usage_string(
    1276             :               "--license or -L"
    1277             :             , "print out the license of arguments and exit."
    1278             :             , 30
    1279             :             , advgetopt::getopt::get_line_width())
    1280             : + advgetopt::getopt::format_usage_string(
    1281             :               "--long-help or -?"
    1282             :             , "show all the help from all the available options."
    1283             :             , 30
    1284             :             , advgetopt::getopt::get_line_width())
    1285             : + advgetopt::getopt::format_usage_string(
    1286             :               "--obscure or -o <arg>"
    1287             :             , "obscure command, hidden by default."
    1288             :             , 30
    1289             :             , advgetopt::getopt::get_line_width())
    1290             : + advgetopt::getopt::format_usage_string(
    1291             :               "--path-to-option-definitions"
    1292             :             , "print out the path to the option definitions."
    1293             :             , 30
    1294             :             , advgetopt::getopt::get_line_width())
    1295             : + advgetopt::getopt::format_usage_string(
    1296             :               "--secret or -S <arg>"
    1297             :             , "even more secret command, hidden by default."
    1298             :             , 30
    1299             :             , advgetopt::getopt::get_line_width())
    1300             : + advgetopt::getopt::format_usage_string(
    1301             :               "--show-option-sources"
    1302             :             , "parse all the options and then print out the source of each"
    1303             :               " value and each override."
    1304             :             , 30
    1305             :             , advgetopt::getopt::get_line_width())
    1306             : + advgetopt::getopt::format_usage_string(
    1307             :               "--size or -s <arg> (default is \"33\")"
    1308             :             , "define the size."
    1309             :             , 30
    1310             :             , advgetopt::getopt::get_line_width())
    1311             : + advgetopt::getopt::format_usage_string(
    1312             :               "--version or -V"
    1313             :             , "print out the version of arguments and exit."
    1314             :             , 30
    1315             :             , advgetopt::getopt::get_line_width())
    1316             : + "\n"
    1317             :   "Copyright matters\n"
    1318             :   "\n"
    1319             :                     );
    1320             :     }
    1321             :     CATCH_END_SECTION()
    1322             : 
    1323          10 :     CATCH_START_SECTION("Check with the --help system flag, without a --help on the command line")
    1324           1 :         advgetopt::option const options[] =
    1325             :         {
    1326             :             advgetopt::define_option(
    1327             :                   advgetopt::Name("size")
    1328             :                 , advgetopt::ShortName('s')
    1329             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1330             :                 , advgetopt::Help("define the size.")
    1331             :                 , advgetopt::DefaultValue("33")
    1332             :             ),
    1333             :             advgetopt::end_options()
    1334             :         };
    1335             : 
    1336           1 :         advgetopt::options_environment environment_options;
    1337           1 :         environment_options.f_project_name = "unittest";
    1338           1 :         environment_options.f_options = options;
    1339           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1340           1 :         environment_options.f_help_header = "Usage: test system commands";
    1341           1 :         environment_options.f_help_footer = "Copyright matters";
    1342             : 
    1343           1 :         char const * cargv[] =
    1344             :         {
    1345             :             "/usr/bin/arguments",
    1346             :             "--size",
    1347             :             "1221",
    1348             :             nullptr
    1349             :         };
    1350           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1351           1 :         char ** argv = const_cast<char **>(cargv);
    1352             : 
    1353           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1354             : 
    1355             :         // check that the result is valid
    1356             : 
    1357             :         // an invalid parameter, MUST NOT EXIST
    1358           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1359           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1360           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1361           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1362           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1363             : 
    1364             :         // no default
    1365           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1366           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1367           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1368           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1369             : 
    1370             :         // valid parameter
    1371           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1372           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1373           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    1374           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    1375           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    1376           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    1377           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    1378           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    1379           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1380           1 :         CATCH_REQUIRE(opt.get_default("size") == "33");
    1381           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    1382             : 
    1383             :         // help parameter
    1384           1 :         CATCH_REQUIRE(opt.get_option("help") != nullptr);
    1385           1 :         CATCH_REQUIRE(opt.get_option('h') == opt.get_option("help"));
    1386           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("help"));
    1387           1 :         CATCH_REQUIRE_FALSE(opt.has_default("help"));
    1388           1 :         CATCH_REQUIRE(opt.get_default("help").empty());
    1389           1 :         CATCH_REQUIRE(opt.size("help") == 0);
    1390             : 
    1391             :         // other parameters
    1392           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1393           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1394             : 
    1395             :         // process system options now
    1396           2 :         std::stringstream ss;
    1397           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1398           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    1399           1 :         CATCH_REQUIRE(ss.str().empty());
    1400             :     CATCH_END_SECTION()
    1401             : 
    1402          10 :     CATCH_START_SECTION("Check with the --commmands-help system flag")
    1403             :     {
    1404           1 :         advgetopt::option const options[] =
    1405             :         {
    1406             :             advgetopt::define_option(
    1407             :                   advgetopt::Name("size")
    1408             :                 , advgetopt::ShortName('s')
    1409             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1410             :                                                           , advgetopt::GETOPT_FLAG_GROUP_COMMANDS>())
    1411             :                 , advgetopt::Help("define the size.")
    1412             :                 , advgetopt::DefaultValue("33")
    1413             :             ),
    1414             :             advgetopt::define_option(
    1415             :                   advgetopt::Name("obscure")
    1416             :                 , advgetopt::ShortName('o')
    1417             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1418             :                                                           , advgetopt::GETOPT_FLAG_GROUP_COMMANDS>())
    1419             :                 , advgetopt::Help("obscure command, hidden by default.")
    1420             :             ),
    1421             :             advgetopt::define_option(
    1422             :                   advgetopt::Name("secret")
    1423             :                 , advgetopt::ShortName('S')
    1424             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1425             :                                                           , advgetopt::GETOPT_FLAG_GROUP_OPTIONS>())
    1426             :                 , advgetopt::Help("even more secret command, hidden by default.")
    1427             :             ),
    1428             :             advgetopt::end_options()
    1429             :         };
    1430             : 
    1431           1 :         advgetopt::group_description const groups[] =
    1432             :         {
    1433             :             advgetopt::define_group(
    1434             :                   advgetopt::GroupNumber(advgetopt::GETOPT_FLAG_GROUP_COMMANDS)
    1435             :                 , advgetopt::GroupName("commands")
    1436             :                 , advgetopt::GroupDescription("Commands:")
    1437             :             ),
    1438             :             advgetopt::define_group(
    1439             :                   advgetopt::GroupNumber(advgetopt::GETOPT_FLAG_GROUP_OPTIONS)
    1440             :                 , advgetopt::GroupName("option")
    1441             :                 , advgetopt::GroupDescription("Options:")
    1442             :             ),
    1443             :             advgetopt::end_groups()
    1444             :         };
    1445             : 
    1446           1 :         advgetopt::options_environment environment_options;
    1447           1 :         environment_options.f_project_name = "unittest";
    1448           1 :         environment_options.f_options = options;
    1449           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1450           1 :         environment_options.f_help_header = "Usage: test system commands";
    1451           1 :         environment_options.f_help_footer = "Copyright matters";
    1452           1 :         environment_options.f_groups = groups;
    1453             : 
    1454           1 :         char const * cargv[] =
    1455             :         {
    1456             :             "/usr/bin/arguments",
    1457             :             "--commands-help",
    1458             :             nullptr
    1459             :         };
    1460           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1461           1 :         char ** argv = const_cast<char **>(cargv);
    1462             : 
    1463           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1464             : 
    1465             :         // check that the result is valid
    1466             : 
    1467             :         // an invalid parameter, MUST NOT EXIST
    1468           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1469           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1470           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1471           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1472           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1473             : 
    1474             :         // no default
    1475           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1476           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1477           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1478           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1479             : 
    1480             :         // valid parameter
    1481           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1482           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1483           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1484           1 :         CATCH_REQUIRE(opt.get_string("size") == "33");
    1485           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "33");
    1486           1 :         CATCH_REQUIRE(opt["size"] == "33");
    1487           1 :         CATCH_REQUIRE(opt.get_long("size") == 33);
    1488           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 33);
    1489           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1490           1 :         CATCH_REQUIRE(opt.get_default("size") == "33");
    1491           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1492             : 
    1493             :         // help parameter
    1494           1 :         CATCH_REQUIRE(opt.get_option("commands-help") != nullptr);
    1495           1 :         CATCH_REQUIRE(opt.is_defined("commands-help"));
    1496           1 :         CATCH_REQUIRE(opt.get_string("commands-help") == "");
    1497           1 :         CATCH_REQUIRE(opt.get_string("commands-help", 0) == "");
    1498           1 :         CATCH_REQUIRE(opt["commands-help"] == "");
    1499           1 :         CATCH_REQUIRE_FALSE(opt.has_default("commands-help"));
    1500           1 :         CATCH_REQUIRE(opt.get_default("commands-help").empty());
    1501           1 :         CATCH_REQUIRE(opt.size("commands-help") == 1);
    1502             : 
    1503             :         // other parameters
    1504           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1505           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1506             : 
    1507             :         // process system options now
    1508           2 :         std::stringstream ss;
    1509           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1510           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
    1511           1 :         CATCH_REQUIRE_LONG_STRING(ss.str(),
    1512             : advgetopt::getopt::breakup_line(
    1513             :               "Usage: test system commands"
    1514             :             , 0
    1515             :             , advgetopt::getopt::get_line_width())
    1516             : + "\n"
    1517             :   "Commands:\n"
    1518             : + advgetopt::getopt::format_usage_string(
    1519             :               "--build-date"
    1520             :             , "print out the time and date when arguments was built and exit."
    1521             :             , 30
    1522             :             , advgetopt::getopt::get_line_width())
    1523             : + advgetopt::getopt::format_usage_string(
    1524             :               "--commands-help"
    1525             :             , "show help from the \"commands\" group of options."
    1526             :             , 30
    1527             :             , advgetopt::getopt::get_line_width())
    1528             : + advgetopt::getopt::format_usage_string(
    1529             :               "--compiler-version"
    1530             :             , "print the version of the compiler used to compile the advgetopt library."
    1531             :             , 30
    1532             :             , advgetopt::getopt::get_line_width())
    1533             : + advgetopt::getopt::format_usage_string(
    1534             :               "--configuration-filenames"
    1535             :             , "print out the list of configuration files checked out by this"
    1536             :               " tool."
    1537             :             , 30
    1538             :             , advgetopt::getopt::get_line_width())
    1539             : + advgetopt::getopt::format_usage_string(
    1540             :               "--copyright or -C"
    1541             :             , "print out the copyright of arguments and exit."
    1542             :             , 30
    1543             :             , advgetopt::getopt::get_line_width())
    1544             : + advgetopt::getopt::format_usage_string(
    1545             :               "--environment-variable-name"
    1546             :             , "print out the name of the environment variable supported by"
    1547             :               " arguments (if any.)"
    1548             :             , 30
    1549             :             , advgetopt::getopt::get_line_width())
    1550             : + advgetopt::getopt::format_usage_string(
    1551             :               "--has-sanitizer"
    1552             :             , "print whether the advgetopt was compiled with the sanitizer extension."
    1553             :             , 30
    1554             :             , advgetopt::getopt::get_line_width())
    1555             : + advgetopt::getopt::format_usage_string(
    1556             :               "--help or -h"
    1557             :             , "print out this help screen and exit."
    1558             :             , 30
    1559             :             , advgetopt::getopt::get_line_width())
    1560             : + advgetopt::getopt::format_usage_string(
    1561             :               "--license or -L"
    1562             :             , "print out the license of arguments and exit."
    1563             :             , 30
    1564             :             , advgetopt::getopt::get_line_width())
    1565             : + advgetopt::getopt::format_usage_string(
    1566             :               "--obscure or -o <arg>"
    1567             :             , "obscure command, hidden by default."
    1568             :             , 30
    1569             :             , advgetopt::getopt::get_line_width())
    1570             : + advgetopt::getopt::format_usage_string(
    1571             :               "--option-help"
    1572             :             , "show help from the \"option\" group of options."
    1573             :             , 30
    1574             :             , advgetopt::getopt::get_line_width())
    1575             : + advgetopt::getopt::format_usage_string(
    1576             :               "--path-to-option-definitions"
    1577             :             , "print out the path to the option definitions."
    1578             :             , 30
    1579             :             , advgetopt::getopt::get_line_width())
    1580             : + advgetopt::getopt::format_usage_string(
    1581             :               "--show-option-sources"
    1582             :             , "parse all the options and then print out the source of each"
    1583             :               " value and each override."
    1584             :             , 30
    1585             :             , advgetopt::getopt::get_line_width())
    1586             : + advgetopt::getopt::format_usage_string(
    1587             :               "--size or -s <arg> (default is \"33\")"
    1588             :             , "define the size."
    1589             :             , 30
    1590             :             , advgetopt::getopt::get_line_width())
    1591             : + advgetopt::getopt::format_usage_string(
    1592             :               "--version or -V"
    1593             :             , "print out the version of arguments and exit."
    1594             :             , 30
    1595             :             , advgetopt::getopt::get_line_width())
    1596             : + "\n"
    1597             :   "Copyright matters\n"
    1598             :   "\n"
    1599             :                     );
    1600             :     }
    1601             :     CATCH_END_SECTION()
    1602             : 
    1603          10 :     CATCH_START_SECTION("Check with the --options-help system flag")
    1604             :     {
    1605           1 :         advgetopt::option const options[] =
    1606             :         {
    1607             :             advgetopt::define_option(
    1608             :                   advgetopt::Name("size")
    1609             :                 , advgetopt::ShortName('s')
    1610             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1611             :                                                           , advgetopt::GETOPT_FLAG_GROUP_COMMANDS>())
    1612             :                 , advgetopt::Help("define the size.")
    1613             :                 , advgetopt::DefaultValue("33")
    1614             :             ),
    1615             :             advgetopt::define_option(
    1616             :                   advgetopt::Name("obscure")
    1617             :                 , advgetopt::ShortName('o')
    1618             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1619             :                                                           , advgetopt::GETOPT_FLAG_GROUP_COMMANDS>())
    1620             :                 , advgetopt::Help("obscure command, hidden by default.")
    1621             :             ),
    1622             :             advgetopt::define_option(
    1623             :                   advgetopt::Name("secret")
    1624             :                 , advgetopt::ShortName('S')
    1625             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED
    1626             :                                                           , advgetopt::GETOPT_FLAG_GROUP_OPTIONS>())
    1627             :                 , advgetopt::Help("even more secret command, hidden by default.")
    1628             :             ),
    1629             :             advgetopt::end_options()
    1630             :         };
    1631             : 
    1632           1 :         advgetopt::group_description const groups[] =
    1633             :         {
    1634             :             advgetopt::define_group(
    1635             :                   advgetopt::GroupNumber(advgetopt::GETOPT_FLAG_GROUP_COMMANDS)
    1636             :                 , advgetopt::GroupName("commands")
    1637             :                 , advgetopt::GroupDescription("Commands:")
    1638             :             ),
    1639             :             advgetopt::define_group(
    1640             :                   advgetopt::GroupNumber(advgetopt::GETOPT_FLAG_GROUP_OPTIONS)
    1641             :                 , advgetopt::GroupName("options")
    1642             :                 , advgetopt::GroupDescription("Options:")
    1643             :             ),
    1644             :             advgetopt::end_groups()
    1645             :         };
    1646             : 
    1647           1 :         advgetopt::options_environment environment_options;
    1648           1 :         environment_options.f_project_name = "unittest";
    1649           1 :         environment_options.f_options = options;
    1650           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1651           1 :         environment_options.f_help_header = "Usage: test system commands";
    1652           1 :         environment_options.f_help_footer = "Copyright matters";
    1653           1 :         environment_options.f_groups = groups;
    1654             : 
    1655           1 :         char const * cargv[] =
    1656             :         {
    1657             :             "/usr/bin/arguments",
    1658             :             "--options-help",
    1659             :             nullptr
    1660             :         };
    1661           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1662           1 :         char ** argv = const_cast<char **>(cargv);
    1663             : 
    1664           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1665             : 
    1666             :         // check that the result is valid
    1667             : 
    1668             :         // an invalid parameter, MUST NOT EXIST
    1669           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1670           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1671           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1672           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1673           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1674             : 
    1675             :         // no default
    1676           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1677           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1678           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1679           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1680             : 
    1681             :         // valid parameter
    1682           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1683           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1684           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1685           1 :         CATCH_REQUIRE(opt.get_string("size") == "33");
    1686           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "33");
    1687           1 :         CATCH_REQUIRE(opt["size"] == "33");
    1688           1 :         CATCH_REQUIRE(opt.get_long("size") == 33);
    1689           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 33);
    1690           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1691           1 :         CATCH_REQUIRE(opt.get_default("size") == "33");
    1692           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1693             : 
    1694             :         // help parameter
    1695           1 :         CATCH_REQUIRE(opt.get_option("options-help") != nullptr);
    1696           1 :         CATCH_REQUIRE(opt.is_defined("options-help"));
    1697           1 :         CATCH_REQUIRE(opt.get_string("options-help") == "");
    1698           1 :         CATCH_REQUIRE(opt.get_string("options-help", 0) == "");
    1699           1 :         CATCH_REQUIRE(opt["options-help"] == "");
    1700           1 :         CATCH_REQUIRE_FALSE(opt.has_default("options-help"));
    1701           1 :         CATCH_REQUIRE(opt.get_default("options-help").empty());
    1702           1 :         CATCH_REQUIRE(opt.size("options-help") == 1);
    1703             : 
    1704             :         // other parameters
    1705           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1706           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1707             : 
    1708             :         // process system options now
    1709           2 :         std::stringstream ss;
    1710           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1711           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_HELP);
    1712           1 :         CATCH_REQUIRE_LONG_STRING(ss.str(),
    1713             : "Usage: test system commands\n"
    1714             : "\n"
    1715             : "Options:\n"
    1716             : "   --secret or -S <arg>       even more secret command, hidden by default.\n"
    1717             : "\n"
    1718             : "Copyright matters\n"
    1719             : "\n"
    1720             :                     );
    1721             :     }
    1722             :     CATCH_END_SECTION()
    1723           5 : }
    1724             : 
    1725             : 
    1726             : 
    1727           4 : CATCH_TEST_CASE("system_flags_copyright", "[arguments][valid][getopt][system_flags]")
    1728             : {
    1729           4 :     CATCH_START_SECTION("Check with the --copyright system flag")
    1730             :     {
    1731           1 :         advgetopt::option const options[] =
    1732             :         {
    1733             :             advgetopt::define_option(
    1734             :                   advgetopt::Name("size")
    1735             :                 , advgetopt::ShortName('s')
    1736             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1737             :                 , advgetopt::Help("define the size.")
    1738             :                 , advgetopt::DefaultValue("23")
    1739             :             ),
    1740             :             advgetopt::end_options()
    1741             :         };
    1742             : 
    1743           1 :         advgetopt::options_environment environment_options;
    1744           1 :         environment_options.f_project_name = "unittest";
    1745           1 :         environment_options.f_options = options;
    1746           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1747           1 :         environment_options.f_copyright = "Copyright (c) " BOOST_PP_STRINGIZE(UTC_BUILD_YEAR) "  Made to Order Software Corporation";
    1748             : 
    1749           1 :         char const * cargv[] =
    1750             :         {
    1751             :             "/usr/bin/arguments",
    1752             :             "--copyright",
    1753             :             nullptr
    1754             :         };
    1755           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1756           1 :         char ** argv = const_cast<char **>(cargv);
    1757             : 
    1758           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1759             : 
    1760             :         // check that the result is valid
    1761             : 
    1762             :         // an invalid parameter, MUST NOT EXIST
    1763           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1764           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1765           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1766           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1767           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1768             : 
    1769             :         // no default
    1770           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1771           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1772           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1773           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1774             : 
    1775             :         // valid parameter
    1776           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1777           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1778           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1779           1 :         CATCH_REQUIRE(opt.get_string("size") == "23");
    1780           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "23");
    1781           1 :         CATCH_REQUIRE(opt["size"] == "23");
    1782           1 :         CATCH_REQUIRE(opt.get_long("size") == 23);
    1783           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 23);
    1784           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1785           1 :         CATCH_REQUIRE(opt.get_default("size") == "23");
    1786           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1787             : 
    1788             :         // copyright parameter
    1789           1 :         CATCH_REQUIRE(opt.get_option("copyright") != nullptr);
    1790           1 :         CATCH_REQUIRE(opt.get_option('C') == opt.get_option("copyright"));
    1791           1 :         CATCH_REQUIRE(opt.is_defined("copyright"));
    1792           1 :         CATCH_REQUIRE(opt.get_string("copyright") == "");
    1793           1 :         CATCH_REQUIRE(opt.get_string("copyright", 0) == "");
    1794           1 :         CATCH_REQUIRE(opt["copyright"] == "");
    1795           1 :         CATCH_REQUIRE_FALSE(opt.has_default("copyright"));
    1796           1 :         CATCH_REQUIRE(opt.get_default("copyright").empty());
    1797           1 :         CATCH_REQUIRE(opt.size("copyright") == 1);
    1798             : 
    1799             :         // other parameters
    1800           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1801           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1802             : 
    1803             :         // process system options now
    1804           2 :         std::stringstream ss;
    1805           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1806           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_COPYRIGHT);
    1807           1 :         CATCH_REQUIRE(ss.str() == "Copyright (c) " BOOST_PP_STRINGIZE(UTC_BUILD_YEAR) "  Made to Order Software Corporation\n");
    1808             :     }
    1809             :     CATCH_END_SECTION()
    1810             : 
    1811           4 :     CATCH_START_SECTION("Check with the --copyright system flag, without a --copyright on the command line")
    1812           1 :         advgetopt::option const options[] =
    1813             :         {
    1814             :             advgetopt::define_option(
    1815             :                   advgetopt::Name("size")
    1816             :                 , advgetopt::ShortName('s')
    1817             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1818             :                 , advgetopt::Help("define the size.")
    1819             :                 , advgetopt::DefaultValue("53")
    1820             :             ),
    1821             :             advgetopt::end_options()
    1822             :         };
    1823             : 
    1824           1 :         advgetopt::options_environment environment_options;
    1825           1 :         environment_options.f_project_name = "unittest";
    1826           1 :         environment_options.f_options = options;
    1827           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1828           1 :         environment_options.f_help_header = "Usage: test system commands";
    1829           1 :         environment_options.f_help_footer = "Copyright matters";
    1830             : 
    1831           1 :         char const * cargv[] =
    1832             :         {
    1833             :             "/usr/bin/arguments",
    1834             :             "--size",
    1835             :             "1221",
    1836             :             nullptr
    1837             :         };
    1838           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1839           1 :         char ** argv = const_cast<char **>(cargv);
    1840             : 
    1841           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1842             : 
    1843             :         // check that the result is valid
    1844             : 
    1845             :         // an invalid parameter, MUST NOT EXIST
    1846           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1847           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1848           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1849           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1850           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1851             : 
    1852             :         // no default
    1853           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1854           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1855           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1856           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1857             : 
    1858             :         // valid parameter
    1859           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1860           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1861           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    1862           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    1863           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    1864           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    1865           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    1866           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    1867           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1868           1 :         CATCH_REQUIRE(opt.get_default("size") == "53");
    1869           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    1870             : 
    1871             :         // copyright parameter
    1872           1 :         CATCH_REQUIRE(opt.get_option("copyright") != nullptr);
    1873           1 :         CATCH_REQUIRE(opt.get_option('C') == opt.get_option("copyright"));
    1874           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("copyright"));
    1875           1 :         CATCH_REQUIRE_FALSE(opt.has_default("copyright"));
    1876           1 :         CATCH_REQUIRE(opt.get_default("copyright").empty());
    1877           1 :         CATCH_REQUIRE(opt.size("copyright") == 0);
    1878             : 
    1879             :         // other parameters
    1880           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1881           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1882             : 
    1883             :         // process system options now
    1884           2 :         std::stringstream ss;
    1885           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1886           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    1887           1 :         CATCH_REQUIRE(ss.str().empty());
    1888             :     CATCH_END_SECTION()
    1889           2 : }
    1890             : 
    1891             : 
    1892             : 
    1893           4 : CATCH_TEST_CASE("system_flags_license", "[arguments][valid][getopt][system_flags]")
    1894             : {
    1895           4 :     CATCH_START_SECTION("Check with the --license system flag")
    1896             :     {
    1897           1 :         advgetopt::option const options[] =
    1898             :         {
    1899             :             advgetopt::define_option(
    1900             :                   advgetopt::Name("size")
    1901             :                 , advgetopt::ShortName('s')
    1902             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1903             :                 , advgetopt::Help("define the size.")
    1904             :                 , advgetopt::DefaultValue("73")
    1905             :             ),
    1906             :             advgetopt::end_options()
    1907             :         };
    1908             : 
    1909           1 :         advgetopt::options_environment environment_options;
    1910           1 :         environment_options.f_project_name = "unittest";
    1911           1 :         environment_options.f_options = options;
    1912           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1913           1 :         environment_options.f_license = "GPL v2";
    1914             : 
    1915           1 :         char const * cargv[] =
    1916             :         {
    1917             :             "/usr/bin/arguments",
    1918             :             "--license",
    1919             :             nullptr
    1920             :         };
    1921           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    1922           1 :         char ** argv = const_cast<char **>(cargv);
    1923             : 
    1924           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    1925             : 
    1926             :         // check that the result is valid
    1927             : 
    1928             :         // an invalid parameter, MUST NOT EXIST
    1929           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    1930           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    1931           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    1932           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    1933           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    1934             : 
    1935             :         // no default
    1936           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    1937           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    1938           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    1939           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    1940             : 
    1941             :         // valid parameter
    1942           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    1943           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    1944           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    1945           1 :         CATCH_REQUIRE(opt.get_string("size") == "73");
    1946           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "73");
    1947           1 :         CATCH_REQUIRE(opt["size"] == "73");
    1948           1 :         CATCH_REQUIRE(opt.get_long("size") == 73);
    1949           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 73);
    1950           1 :         CATCH_REQUIRE(opt.has_default("size"));
    1951           1 :         CATCH_REQUIRE(opt.get_default("size") == "73");
    1952           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    1953             : 
    1954             :         // license parameter
    1955           1 :         CATCH_REQUIRE(opt.get_option("license") != nullptr);
    1956           1 :         CATCH_REQUIRE(opt.get_option('L') == opt.get_option("license"));
    1957           1 :         CATCH_REQUIRE(opt.is_defined("license"));
    1958           1 :         CATCH_REQUIRE(opt.get_string("license") == "");
    1959           1 :         CATCH_REQUIRE(opt.get_string("license", 0) == "");
    1960           1 :         CATCH_REQUIRE(opt["license"] == "");
    1961           1 :         CATCH_REQUIRE_FALSE(opt.has_default("license"));
    1962           1 :         CATCH_REQUIRE(opt.get_default("license").empty());
    1963           1 :         CATCH_REQUIRE(opt.size("license") == 1);
    1964             : 
    1965             :         // other parameters
    1966           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    1967           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    1968             : 
    1969             :         // process system options now
    1970           2 :         std::stringstream ss;
    1971           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    1972           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_LICENSE);
    1973           1 :         CATCH_REQUIRE(ss.str() == "GPL v2\n");
    1974             :     }
    1975             :     CATCH_END_SECTION()
    1976             : 
    1977           4 :     CATCH_START_SECTION("Check with the --license system flag, without a --license on the command line")
    1978           1 :         advgetopt::option const options[] =
    1979             :         {
    1980             :             advgetopt::define_option(
    1981             :                   advgetopt::Name("size")
    1982             :                 , advgetopt::ShortName('s')
    1983             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    1984             :                 , advgetopt::Help("define the size.")
    1985             :                 , advgetopt::DefaultValue("103")
    1986             :             ),
    1987             :             advgetopt::end_options()
    1988             :         };
    1989             : 
    1990           1 :         advgetopt::options_environment environment_options;
    1991           1 :         environment_options.f_project_name = "unittest";
    1992           1 :         environment_options.f_options = options;
    1993           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    1994           1 :         environment_options.f_help_header = "Usage: test system commands";
    1995           1 :         environment_options.f_help_footer = "Copyright matters";
    1996             : 
    1997           1 :         char const * cargv[] =
    1998             :         {
    1999             :             "/usr/bin/arguments",
    2000             :             "--size",
    2001             :             "1221",
    2002             :             nullptr
    2003             :         };
    2004           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2005           1 :         char ** argv = const_cast<char **>(cargv);
    2006             : 
    2007           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2008             : 
    2009             :         // check that the result is valid
    2010             : 
    2011             :         // an invalid parameter, MUST NOT EXIST
    2012           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2013           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2014           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2015           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2016           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2017             : 
    2018             :         // no default
    2019           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2020           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2021           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2022           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2023             : 
    2024             :         // valid parameter
    2025           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2026           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2027           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    2028           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    2029           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    2030           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    2031           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    2032           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    2033           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2034           1 :         CATCH_REQUIRE(opt.get_default("size") == "103");
    2035           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    2036             : 
    2037             :         // license parameter
    2038           1 :         CATCH_REQUIRE(opt.get_option("license") != nullptr);
    2039           1 :         CATCH_REQUIRE(opt.get_option('L') == opt.get_option("license"));
    2040           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("license"));
    2041           1 :         CATCH_REQUIRE_FALSE(opt.has_default("license"));
    2042           1 :         CATCH_REQUIRE(opt.get_default("license").empty());
    2043           1 :         CATCH_REQUIRE(opt.size("license") == 0);
    2044             : 
    2045             :         // other parameters
    2046           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2047           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2048             : 
    2049             :         // process system options now
    2050           2 :         std::stringstream ss;
    2051           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2052           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    2053           1 :         CATCH_REQUIRE(ss.str().empty());
    2054             :     CATCH_END_SECTION()
    2055           2 : }
    2056             : 
    2057             : 
    2058             : 
    2059           4 : CATCH_TEST_CASE("system_flags_build_date", "[arguments][valid][getopt][system_flags]")
    2060             : {
    2061           4 :     CATCH_START_SECTION("Check with the --build-date system flag")
    2062             :     {
    2063           1 :         advgetopt::option const options[] =
    2064             :         {
    2065             :             advgetopt::define_option(
    2066             :                   advgetopt::Name("size")
    2067             :                 , advgetopt::ShortName('s')
    2068             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2069             :                 , advgetopt::Help("define the size.")
    2070             :                 , advgetopt::DefaultValue("7301")
    2071             :             ),
    2072             :             advgetopt::end_options()
    2073             :         };
    2074             : 
    2075           1 :         advgetopt::options_environment environment_options;
    2076           1 :         environment_options.f_project_name = "unittest";
    2077           1 :         environment_options.f_options = options;
    2078           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2079             : 
    2080           1 :         char const * cargv[] =
    2081             :         {
    2082             :             "/usr/bin/arguments",
    2083             :             "--build-date",
    2084             :             nullptr
    2085             :         };
    2086           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2087           1 :         char ** argv = const_cast<char **>(cargv);
    2088             : 
    2089           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2090             : 
    2091             :         // check that the result is valid
    2092             : 
    2093             :         // an invalid parameter, MUST NOT EXIST
    2094           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2095           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2096           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2097           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2098           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2099             : 
    2100             :         // no default
    2101           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2102           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2103           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2104           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2105             : 
    2106             :         // valid parameter
    2107           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2108           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2109           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2110           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    2111           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    2112           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    2113           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    2114           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    2115           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2116           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    2117           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2118             : 
    2119             :         // build-date parameter
    2120           1 :         CATCH_REQUIRE(opt.get_option("build-date") != nullptr);
    2121           1 :         CATCH_REQUIRE(opt.is_defined("build-date"));
    2122           1 :         CATCH_REQUIRE(opt.get_string("build-date") == "");
    2123           1 :         CATCH_REQUIRE(opt.get_string("build-date", 0) == "");
    2124           1 :         CATCH_REQUIRE(opt["build-date"] == "");
    2125           1 :         CATCH_REQUIRE_FALSE(opt.has_default("build-date"));
    2126           1 :         CATCH_REQUIRE(opt.get_default("build-date").empty());
    2127           1 :         CATCH_REQUIRE(opt.size("build-date") == 1);
    2128             : 
    2129             :         // other parameters
    2130           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2131           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2132             : 
    2133             :         // process system options now
    2134           2 :         std::stringstream ss;
    2135           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2136           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_BUILD_DATE);
    2137           1 :         CATCH_REQUIRE(ss.str() == "Built on "
    2138             :                                 + std::string(environment_options.f_build_date)
    2139             :                                 + " at "
    2140             :                                 + environment_options.f_build_time
    2141             :                                 + "\n");
    2142             :     }
    2143             :     CATCH_END_SECTION()
    2144             : 
    2145           4 :     CATCH_START_SECTION("Check with the --build-date system flag, without a --build-date on the command line")
    2146           1 :         advgetopt::option const options[] =
    2147             :         {
    2148             :             advgetopt::define_option(
    2149             :                   advgetopt::Name("size")
    2150             :                 , advgetopt::ShortName('s')
    2151             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2152             :                 , advgetopt::Help("define the size.")
    2153             :                 , advgetopt::DefaultValue("103")
    2154             :             ),
    2155             :             advgetopt::end_options()
    2156             :         };
    2157             : 
    2158           1 :         advgetopt::options_environment environment_options;
    2159           1 :         environment_options.f_project_name = "unittest";
    2160           1 :         environment_options.f_options = options;
    2161           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2162           1 :         environment_options.f_help_header = "Usage: test system commands";
    2163           1 :         environment_options.f_help_footer = "Copyright matters";
    2164             : 
    2165           1 :         char const * cargv[] =
    2166             :         {
    2167             :             "/usr/bin/arguments",
    2168             :             "--size",
    2169             :             "1221",
    2170             :             nullptr
    2171             :         };
    2172           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2173           1 :         char ** argv = const_cast<char **>(cargv);
    2174             : 
    2175           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2176             : 
    2177             :         // check that the result is valid
    2178             : 
    2179             :         // an invalid parameter, MUST NOT EXIST
    2180           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2181           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2182           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2183           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2184           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2185             : 
    2186             :         // no default
    2187           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2188           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2189           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2190           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2191             : 
    2192             :         // valid parameter
    2193           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2194           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2195           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    2196           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    2197           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    2198           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    2199           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    2200           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    2201           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2202           1 :         CATCH_REQUIRE(opt.get_default("size") == "103");
    2203           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    2204             : 
    2205             :         // build-date parameter
    2206           1 :         CATCH_REQUIRE(opt.get_option("build-date") != nullptr);
    2207           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("build-date"));
    2208           1 :         CATCH_REQUIRE_FALSE(opt.has_default("build-date"));
    2209           1 :         CATCH_REQUIRE(opt.get_default("build-date").empty());
    2210           1 :         CATCH_REQUIRE(opt.size("build-date") == 0);
    2211             : 
    2212             :         // other parameters
    2213           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2214           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2215             : 
    2216             :         // process system options now
    2217           2 :         std::stringstream ss;
    2218           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2219           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    2220           1 :         CATCH_REQUIRE(ss.str().empty());
    2221             :     CATCH_END_SECTION()
    2222           2 : }
    2223             : 
    2224             : 
    2225             : 
    2226           6 : CATCH_TEST_CASE("system_flags_environment_variable_name", "[arguments][valid][getopt][system_flags]")
    2227             : {
    2228           8 :     CATCH_START_SECTION("Check with the --environment-variable-name system flag")
    2229             :     {
    2230           1 :         advgetopt::option const options[] =
    2231             :         {
    2232             :             advgetopt::define_option(
    2233             :                   advgetopt::Name("size")
    2234             :                 , advgetopt::ShortName('s')
    2235             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2236             :                 , advgetopt::Help("define the size.")
    2237             :                 , advgetopt::DefaultValue("7301")
    2238             :             ),
    2239             :             advgetopt::end_options()
    2240             :         };
    2241             : 
    2242           1 :         advgetopt::options_environment environment_options;
    2243           1 :         environment_options.f_project_name = "unittest";
    2244           1 :         environment_options.f_options = options;
    2245           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2246           1 :         environment_options.f_environment_variable_name = "ADVGETOPT_OPTIONS";
    2247             : 
    2248           1 :         char const * cargv[] =
    2249             :         {
    2250             :             "/usr/bin/arguments",
    2251             :             "--environment-variable-name",
    2252             :             nullptr
    2253             :         };
    2254           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2255           1 :         char ** argv = const_cast<char **>(cargv);
    2256             : 
    2257           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2258             : 
    2259             :         // check that the result is valid
    2260             : 
    2261             :         // an invalid parameter, MUST NOT EXIST
    2262           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2263           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2264           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2265           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2266           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2267             : 
    2268             :         // no default
    2269           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2270           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2271           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2272           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2273             : 
    2274             :         // valid parameter
    2275           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2276           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2277           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2278           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    2279           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    2280           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    2281           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    2282           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    2283           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2284           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    2285           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2286             : 
    2287             :         // environment-variable-name parameter
    2288           1 :         CATCH_REQUIRE(opt.get_option("environment-variable-name") != nullptr);
    2289           1 :         CATCH_REQUIRE(opt.is_defined("environment-variable-name"));
    2290           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name") == "");
    2291           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name", 0) == "");
    2292           1 :         CATCH_REQUIRE(opt["environment-variable-name"] == "");
    2293           1 :         CATCH_REQUIRE_FALSE(opt.has_default("environment-variable-name"));
    2294           1 :         CATCH_REQUIRE(opt.get_default("environment-variable-name").empty());
    2295           1 :         CATCH_REQUIRE(opt.size("environment-variable-name") == 1);
    2296             : 
    2297             :         // other parameters
    2298           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2299           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2300             : 
    2301             :         // process system options now
    2302           2 :         std::stringstream ss;
    2303           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2304           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_ENVIRONMENT_VARIABLE_NAME);
    2305           1 :         CATCH_REQUIRE(ss.str() == "ADVGETOPT_OPTIONS\n");
    2306             :     }
    2307             :     CATCH_END_SECTION()
    2308             : 
    2309           8 :     CATCH_START_SECTION("Check with the --environment-variable-name system flag with nullptr")
    2310             :     {
    2311           1 :         advgetopt::option const options[] =
    2312             :         {
    2313             :             advgetopt::define_option(
    2314             :                   advgetopt::Name("size")
    2315             :                 , advgetopt::ShortName('s')
    2316             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2317             :                 , advgetopt::Help("define the size.")
    2318             :                 , advgetopt::DefaultValue("7301")
    2319             :             ),
    2320             :             advgetopt::end_options()
    2321             :         };
    2322             : 
    2323           1 :         advgetopt::options_environment environment_options;
    2324           1 :         environment_options.f_project_name = "unittest";
    2325           1 :         environment_options.f_options = options;
    2326           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2327           1 :         environment_options.f_environment_variable_name = nullptr;
    2328             : 
    2329           1 :         char const * cargv[] =
    2330             :         {
    2331             :             "/usr/bin/arguments",
    2332             :             "--environment-variable-name",
    2333             :             nullptr
    2334             :         };
    2335           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2336           1 :         char ** argv = const_cast<char **>(cargv);
    2337             : 
    2338           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2339             : 
    2340             :         // check that the result is valid
    2341             : 
    2342             :         // an invalid parameter, MUST NOT EXIST
    2343           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2344           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2345           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2346           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2347           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2348             : 
    2349             :         // no default
    2350           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2351           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2352           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2353           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2354             : 
    2355             :         // valid parameter
    2356           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2357           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2358           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2359           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    2360           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    2361           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    2362           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    2363           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    2364           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2365           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    2366           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2367             : 
    2368             :         // environment-variable-name parameter
    2369           1 :         CATCH_REQUIRE(opt.get_option("environment-variable-name") != nullptr);
    2370           1 :         CATCH_REQUIRE(opt.is_defined("environment-variable-name"));
    2371           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name") == "");
    2372           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name", 0) == "");
    2373           1 :         CATCH_REQUIRE(opt["environment-variable-name"] == "");
    2374           1 :         CATCH_REQUIRE_FALSE(opt.has_default("environment-variable-name"));
    2375           1 :         CATCH_REQUIRE(opt.get_default("environment-variable-name").empty());
    2376           1 :         CATCH_REQUIRE(opt.size("environment-variable-name") == 1);
    2377             : 
    2378             :         // other parameters
    2379           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2380           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2381             : 
    2382             :         // process system options now
    2383           2 :         std::stringstream ss;
    2384           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2385           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_ENVIRONMENT_VARIABLE_NAME);
    2386           1 :         CATCH_REQUIRE(ss.str() == "unittest does not support an environment variable.\n");
    2387             :     }
    2388             :     CATCH_END_SECTION()
    2389             : 
    2390           8 :     CATCH_START_SECTION("Check with the --environment-variable-name system flag with \"\"")
    2391             :     {
    2392           1 :         advgetopt::option const options[] =
    2393             :         {
    2394             :             advgetopt::define_option(
    2395             :                   advgetopt::Name("size")
    2396             :                 , advgetopt::ShortName('s')
    2397             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2398             :                 , advgetopt::Help("define the size.")
    2399             :                 , advgetopt::DefaultValue("7301")
    2400             :             ),
    2401             :             advgetopt::end_options()
    2402             :         };
    2403             : 
    2404           1 :         advgetopt::options_environment environment_options;
    2405           1 :         environment_options.f_project_name = "unittest";
    2406           1 :         environment_options.f_options = options;
    2407           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2408           1 :         environment_options.f_environment_variable_name = "";
    2409             : 
    2410           1 :         char const * cargv[] =
    2411             :         {
    2412             :             "/usr/bin/arguments",
    2413             :             "--environment-variable-name",
    2414             :             nullptr
    2415             :         };
    2416           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2417           1 :         char ** argv = const_cast<char **>(cargv);
    2418             : 
    2419           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2420             : 
    2421             :         // check that the result is valid
    2422             : 
    2423             :         // an invalid parameter, MUST NOT EXIST
    2424           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2425           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2426           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2427           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2428           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2429             : 
    2430             :         // no default
    2431           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2432           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2433           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2434           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2435             : 
    2436             :         // valid parameter
    2437           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2438           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2439           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2440           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    2441           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    2442           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    2443           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    2444           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    2445           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2446           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    2447           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2448             : 
    2449             :         // environment-variable-name parameter
    2450           1 :         CATCH_REQUIRE(opt.get_option("environment-variable-name") != nullptr);
    2451           1 :         CATCH_REQUIRE(opt.is_defined("environment-variable-name"));
    2452           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name") == "");
    2453           1 :         CATCH_REQUIRE(opt.get_string("environment-variable-name", 0) == "");
    2454           1 :         CATCH_REQUIRE(opt["environment-variable-name"] == "");
    2455           1 :         CATCH_REQUIRE_FALSE(opt.has_default("environment-variable-name"));
    2456           1 :         CATCH_REQUIRE(opt.get_default("environment-variable-name").empty());
    2457           1 :         CATCH_REQUIRE(opt.size("environment-variable-name") == 1);
    2458             : 
    2459             :         // other parameters
    2460           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2461           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2462             : 
    2463             :         // process system options now
    2464           2 :         std::stringstream ss;
    2465           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2466           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_ENVIRONMENT_VARIABLE_NAME);
    2467           1 :         CATCH_REQUIRE(ss.str() == "unittest does not support an environment variable.\n");
    2468             :     }
    2469             :     CATCH_END_SECTION()
    2470             : 
    2471           8 :     CATCH_START_SECTION("Check with the --environment-variable-name system flag, without a --environment-variable-name on the command line")
    2472           1 :         advgetopt::option const options[] =
    2473             :         {
    2474             :             advgetopt::define_option(
    2475             :                   advgetopt::Name("size")
    2476             :                 , advgetopt::ShortName('s')
    2477             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2478             :                 , advgetopt::Help("define the size.")
    2479             :                 , advgetopt::DefaultValue("103")
    2480             :             ),
    2481             :             advgetopt::end_options()
    2482             :         };
    2483             : 
    2484           1 :         advgetopt::options_environment environment_options;
    2485           1 :         environment_options.f_project_name = "unittest";
    2486           1 :         environment_options.f_options = options;
    2487           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2488           1 :         environment_options.f_help_header = "Usage: test system commands";
    2489           1 :         environment_options.f_help_footer = "Copyright matters";
    2490             : 
    2491           1 :         char const * cargv[] =
    2492             :         {
    2493             :             "/usr/bin/arguments",
    2494             :             "--size",
    2495             :             "1221",
    2496             :             nullptr
    2497             :         };
    2498           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2499           1 :         char ** argv = const_cast<char **>(cargv);
    2500             : 
    2501           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2502             : 
    2503             :         // check that the result is valid
    2504             : 
    2505             :         // an invalid parameter, MUST NOT EXIST
    2506           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2507           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2508           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2509           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2510           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2511             : 
    2512             :         // no default
    2513           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2514           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2515           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2516           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2517             : 
    2518             :         // valid parameter
    2519           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2520           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2521           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    2522           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    2523           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    2524           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    2525           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    2526           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    2527           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2528           1 :         CATCH_REQUIRE(opt.get_default("size") == "103");
    2529           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    2530             : 
    2531             :         // environment-variable-name parameter
    2532           1 :         CATCH_REQUIRE(opt.get_option("environment-variable-name") != nullptr);
    2533           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("environment-variable-name"));
    2534           1 :         CATCH_REQUIRE_FALSE(opt.has_default("environment-variable-name"));
    2535           1 :         CATCH_REQUIRE(opt.get_default("environment-variable-name").empty());
    2536           1 :         CATCH_REQUIRE(opt.size("environment-variable-name") == 0);
    2537             : 
    2538             :         // other parameters
    2539           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2540           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2541             : 
    2542             :         // process system options now
    2543           2 :         std::stringstream ss;
    2544           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2545           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    2546           1 :         CATCH_REQUIRE(ss.str().empty());
    2547             :     CATCH_END_SECTION()
    2548           4 : }
    2549             : 
    2550             : 
    2551             : 
    2552           6 : CATCH_TEST_CASE("system_flags_configuration_filenames", "[arguments][valid][getopt][system_flags]")
    2553             : {
    2554           8 :     CATCH_START_SECTION("Check with the --configuration-filenames system flag")
    2555             :     {
    2556           2 :         snapdev::safe_setenv env("HOME", "/home/advgetopt");
    2557             : 
    2558           1 :         advgetopt::option const options[] =
    2559             :         {
    2560             :             advgetopt::define_option(
    2561             :                   advgetopt::Name("size")
    2562             :                 , advgetopt::ShortName('s')
    2563             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2564             :                 , advgetopt::Help("define the size.")
    2565             :                 , advgetopt::DefaultValue("3101")
    2566             :             ),
    2567             :             advgetopt::end_options()
    2568             :         };
    2569             : 
    2570           1 :         char const * confs[] =
    2571             :         {
    2572             :             ".config/file.mdi",
    2573             :             "/etc/snapwebsites/server.conf",
    2574             :             "~/.config/advgetopt/snap.conf",
    2575             :             nullptr
    2576             :         };
    2577           1 :         char const * dirs[] =
    2578             :         {
    2579             :             ".config",
    2580             :             "/etc/secret",
    2581             :             "~/.config/snapwebsites",
    2582             :             nullptr
    2583             :         };
    2584             : 
    2585           1 :         advgetopt::options_environment environment_options;
    2586           1 :         environment_options.f_project_name = "unittest";
    2587           1 :         environment_options.f_options = options;
    2588           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2589           1 :         environment_options.f_configuration_files = confs;
    2590           1 :         environment_options.f_configuration_filename = "snapdb.conf";
    2591           1 :         environment_options.f_configuration_directories = dirs;
    2592             : 
    2593           1 :         char const * cargv[] =
    2594             :         {
    2595             :             "/usr/bin/arguments",
    2596             :             "--configuration-filenames",
    2597             :             nullptr
    2598             :         };
    2599           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2600           1 :         char ** argv = const_cast<char **>(cargv);
    2601             : 
    2602           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2603             : 
    2604             :         // check that the result is valid
    2605             : 
    2606             :         // an invalid parameter, MUST NOT EXIST
    2607           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2608           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2609           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2610           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2611           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2612             : 
    2613             :         // no default
    2614           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2615           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2616           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2617           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2618             : 
    2619             :         // valid parameter
    2620           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2621           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2622           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2623           1 :         CATCH_REQUIRE(opt.get_string("size") == "3101");
    2624           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "3101");
    2625           1 :         CATCH_REQUIRE(opt["size"] == "3101");
    2626           1 :         CATCH_REQUIRE(opt.get_long("size") == 3101);
    2627           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 3101);
    2628           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2629           1 :         CATCH_REQUIRE(opt.get_default("size") == "3101");
    2630           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2631             : 
    2632             :         // configuration-filenames parameter
    2633           1 :         CATCH_REQUIRE(opt.get_option("configuration-filenames") != nullptr);
    2634           1 :         CATCH_REQUIRE(opt.is_defined("configuration-filenames"));
    2635           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames") == "");
    2636           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames", 0) == "");
    2637           1 :         CATCH_REQUIRE(opt["configuration-filenames"] == "");
    2638           1 :         CATCH_REQUIRE_FALSE(opt.has_default("configuration-filenames"));
    2639           1 :         CATCH_REQUIRE(opt.get_default("configuration-filenames").empty());
    2640           1 :         CATCH_REQUIRE(opt.size("configuration-filenames") == 1);
    2641             : 
    2642             :         // other parameters
    2643           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2644           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2645             : 
    2646             :         // process system options now
    2647           2 :         std::stringstream ss;
    2648           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2649           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_CONFIGURATION_FILENAMES);
    2650           1 :         CATCH_REQUIRE(getenv("HOME") != nullptr);
    2651           2 :         std::string const home(getenv("HOME"));
    2652           1 :         CATCH_REQUIRE(ss.str() ==
    2653             : "Configuration filenames:\n"
    2654             : " . .config/file.mdi\n"
    2655             : " . .config/unittest.d/50-file.mdi\n"
    2656             : " . /etc/snapwebsites/server.conf\n"
    2657             : " . /etc/snapwebsites/unittest.d/50-server.conf\n"
    2658             : " . " + home + "/.config/advgetopt/snap.conf\n"
    2659             : " . .config/snapdb.conf\n"
    2660             : " . .config/unittest.d/50-snapdb.conf\n"
    2661             : " . /etc/secret/snapdb.conf\n"
    2662             : " . /etc/secret/unittest.d/50-snapdb.conf\n"
    2663             : " . " + home + "/.config/snapwebsites/snapdb.conf\n"
    2664             : );
    2665             :     }
    2666             :     CATCH_END_SECTION()
    2667             : 
    2668           8 :     CATCH_START_SECTION("Check with the --configuration-filenames system flag with --config-dir too")
    2669             :     {
    2670           2 :         snapdev::safe_setenv env("HOME", "/home/advgetopt");
    2671             : 
    2672           1 :         advgetopt::option const options[] =
    2673             :         {
    2674             :             advgetopt::define_option(
    2675             :                   advgetopt::Name("size")
    2676             :                 , advgetopt::ShortName('s')
    2677             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2678             :                 , advgetopt::Help("define the size.")
    2679             :                 , advgetopt::DefaultValue("3101")
    2680             :             ),
    2681             :             advgetopt::end_options()
    2682             :         };
    2683             : 
    2684           1 :         char const * confs[] =
    2685             :         {
    2686             :             ".config/file.mdi",
    2687             :             "/etc/snapwebsites/server.conf",
    2688             :             "~/.config/advgetopt/snap.conf",
    2689             :             nullptr
    2690             :         };
    2691           1 :         char const * dirs[] =
    2692             :         {
    2693             :             ".config",
    2694             :             "/etc/secret",
    2695             :             "~/.config/snapwebsites",
    2696             :             nullptr
    2697             :         };
    2698             : 
    2699           1 :         advgetopt::options_environment environment_options;
    2700           1 :         environment_options.f_project_name = "unittest";
    2701           1 :         environment_options.f_options = options;
    2702           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2703           1 :         environment_options.f_configuration_files = confs;
    2704           1 :         environment_options.f_configuration_filename = "snapdb.conf";
    2705           1 :         environment_options.f_configuration_directories = dirs;
    2706             : 
    2707           1 :         char const * cargv[] =
    2708             :         {
    2709             :             "/usr/bin/arguments",
    2710             :             "--config-dir",
    2711             :             "/var/lib/advgetopt",
    2712             :             "--configuration-filenames",
    2713             :             "--config-dir",
    2714             :             "/opt/config",
    2715             :             nullptr
    2716             :         };
    2717           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2718           1 :         char ** argv = const_cast<char **>(cargv);
    2719             : 
    2720           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2721             : 
    2722             :         // check that the result is valid
    2723             : 
    2724             :         // an invalid parameter, MUST NOT EXIST
    2725           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2726           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2727           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2728           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2729           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2730             : 
    2731             :         // no default
    2732           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2733           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2734           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2735           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2736             : 
    2737             :         // valid parameter
    2738           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2739           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2740           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2741           1 :         CATCH_REQUIRE(opt.get_string("size") == "3101");
    2742           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "3101");
    2743           1 :         CATCH_REQUIRE(opt["size"] == "3101");
    2744           1 :         CATCH_REQUIRE(opt.get_long("size") == 3101);
    2745           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 3101);
    2746           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2747           1 :         CATCH_REQUIRE(opt.get_default("size") == "3101");
    2748           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2749             : 
    2750             :         // configuration-filenames parameter
    2751           1 :         CATCH_REQUIRE(opt.get_option("configuration-filenames") != nullptr);
    2752           1 :         CATCH_REQUIRE(opt.is_defined("configuration-filenames"));
    2753           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames") == "");
    2754           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames", 0) == "");
    2755           1 :         CATCH_REQUIRE(opt["configuration-filenames"] == "");
    2756           1 :         CATCH_REQUIRE_FALSE(opt.has_default("configuration-filenames"));
    2757           1 :         CATCH_REQUIRE(opt.get_default("configuration-filenames").empty());
    2758           1 :         CATCH_REQUIRE(opt.size("configuration-filenames") == 1);
    2759             : 
    2760             :         // other parameters
    2761           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2762           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2763             : 
    2764             :         // process system options now
    2765           2 :         std::stringstream ss;
    2766           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2767           1 :         CATCH_REQUIRE(result == (advgetopt::SYSTEM_OPTION_CONFIGURATION_FILENAMES
    2768             :                                | advgetopt::SYSTEM_OPTION_CONFIG_DIR));
    2769           1 :         CATCH_REQUIRE(getenv("HOME") != nullptr);
    2770           2 :         std::string const home(getenv("HOME"));
    2771           1 :         CATCH_REQUIRE(ss.str() ==
    2772             : "Configuration filenames:\n"
    2773             : " . .config/file.mdi\n"
    2774             : " . .config/unittest.d/50-file.mdi\n"
    2775             : " . /etc/snapwebsites/server.conf\n"
    2776             : " . /etc/snapwebsites/unittest.d/50-server.conf\n"
    2777             : " . " + home + "/.config/advgetopt/snap.conf\n"
    2778             : " . /var/lib/advgetopt/snapdb.conf\n"
    2779             : " . /var/lib/advgetopt/unittest.d/50-snapdb.conf\n"
    2780             : " . /opt/config/snapdb.conf\n"
    2781             : " . /opt/config/unittest.d/50-snapdb.conf\n"
    2782             : " . .config/snapdb.conf\n"
    2783             : " . .config/unittest.d/50-snapdb.conf\n"
    2784             : " . /etc/secret/snapdb.conf\n"
    2785             : " . /etc/secret/unittest.d/50-snapdb.conf\n"
    2786             : " . " + home + "/.config/snapwebsites/snapdb.conf\n"
    2787             : );
    2788             :     }
    2789             :     CATCH_END_SECTION()
    2790             : 
    2791           8 :     CATCH_START_SECTION("Check with the --configuration-filenames system flag without any configuration files")
    2792             :     {
    2793           1 :         advgetopt::option const options[] =
    2794             :         {
    2795             :             advgetopt::define_option(
    2796             :                   advgetopt::Name("size")
    2797             :                 , advgetopt::ShortName('s')
    2798             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2799             :                 , advgetopt::Help("define the size.")
    2800             :                 , advgetopt::DefaultValue("3101")
    2801             :             ),
    2802             :             advgetopt::end_options()
    2803             :         };
    2804             : 
    2805           1 :         advgetopt::options_environment environment_options;
    2806           1 :         environment_options.f_project_name = "unittest";
    2807           1 :         environment_options.f_options = options;
    2808           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2809             : 
    2810           1 :         char const * cargv[] =
    2811             :         {
    2812             :             "/usr/bin/arguments",
    2813             :             "--configuration-filenames",
    2814             :             nullptr
    2815             :         };
    2816           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2817           1 :         char ** argv = const_cast<char **>(cargv);
    2818             : 
    2819           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2820             : 
    2821             :         // check that the result is valid
    2822             : 
    2823             :         // an invalid parameter, MUST NOT EXIST
    2824           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2825           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2826           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2827           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2828           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2829             : 
    2830             :         // no default
    2831           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2832           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2833           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2834           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2835             : 
    2836             :         // valid parameter
    2837           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2838           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2839           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    2840           1 :         CATCH_REQUIRE(opt.get_string("size") == "3101");
    2841           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "3101");
    2842           1 :         CATCH_REQUIRE(opt["size"] == "3101");
    2843           1 :         CATCH_REQUIRE(opt.get_long("size") == 3101);
    2844           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 3101);
    2845           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2846           1 :         CATCH_REQUIRE(opt.get_default("size") == "3101");
    2847           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    2848             : 
    2849             :         // configuration-filenames parameter
    2850           1 :         CATCH_REQUIRE(opt.get_option("configuration-filenames") != nullptr);
    2851           1 :         CATCH_REQUIRE(opt.is_defined("configuration-filenames"));
    2852           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames") == "");
    2853           1 :         CATCH_REQUIRE(opt.get_string("configuration-filenames", 0) == "");
    2854           1 :         CATCH_REQUIRE(opt["configuration-filenames"] == "");
    2855           1 :         CATCH_REQUIRE_FALSE(opt.has_default("configuration-filenames"));
    2856           1 :         CATCH_REQUIRE(opt.get_default("configuration-filenames").empty());
    2857           1 :         CATCH_REQUIRE(opt.size("configuration-filenames") == 1);
    2858             : 
    2859             :         // other parameters
    2860           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2861           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2862             : 
    2863             :         // process system options now
    2864           2 :         std::stringstream ss;
    2865           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2866           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_CONFIGURATION_FILENAMES);
    2867           1 :         CATCH_REQUIRE(ss.str() == "unittest does not support configuration files.\n");
    2868             :     }
    2869             :     CATCH_END_SECTION()
    2870             : 
    2871           8 :     CATCH_START_SECTION("Check with the --configuration-filenames system flag, without a --configuration-filenames on the command line")
    2872           1 :         advgetopt::option const options[] =
    2873             :         {
    2874             :             advgetopt::define_option(
    2875             :                   advgetopt::Name("size")
    2876             :                 , advgetopt::ShortName('s')
    2877             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2878             :                 , advgetopt::Help("define the size.")
    2879             :                 , advgetopt::DefaultValue("193")
    2880             :             ),
    2881             :             advgetopt::end_options()
    2882             :         };
    2883             : 
    2884           1 :         char const * confs[] =
    2885             :         {
    2886             :             ".config/file.mdi",
    2887             :             "/etc/snapwebsites/server.conf",
    2888             :             "~/.config/advgetopt/snap.conf",
    2889             :             nullptr
    2890             :         };
    2891           1 :         char const * dirs[] =
    2892             :         {
    2893             :             ".config",
    2894             :             "/etc/secret",
    2895             :             "~/.config/snapwebsites",
    2896             :             nullptr
    2897             :         };
    2898             : 
    2899           1 :         advgetopt::options_environment environment_options;
    2900           1 :         environment_options.f_project_name = "unittest";
    2901           1 :         environment_options.f_options = options;
    2902           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2903           1 :         environment_options.f_help_header = "Usage: test system commands";
    2904           1 :         environment_options.f_help_footer = "Copyright matters";
    2905           1 :         environment_options.f_configuration_files = confs;
    2906           1 :         environment_options.f_configuration_filename = "snapdb.conf";
    2907           1 :         environment_options.f_configuration_directories = dirs;
    2908             : 
    2909           1 :         char const * cargv[] =
    2910             :         {
    2911             :             "/usr/bin/arguments",
    2912             :             "--size",
    2913             :             "1221",
    2914             :             nullptr
    2915             :         };
    2916           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2917           1 :         char ** argv = const_cast<char **>(cargv);
    2918             : 
    2919           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    2920             : 
    2921             :         // check that the result is valid
    2922             : 
    2923             :         // an invalid parameter, MUST NOT EXIST
    2924           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    2925           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    2926           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    2927           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    2928           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    2929             : 
    2930             :         // no default
    2931           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    2932           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    2933           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    2934           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    2935             : 
    2936             :         // valid parameter
    2937           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    2938           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    2939           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    2940           1 :         CATCH_REQUIRE(opt.get_string("size") == "1221");
    2941           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1221");
    2942           1 :         CATCH_REQUIRE(opt["size"] == "1221");
    2943           1 :         CATCH_REQUIRE(opt.get_long("size") == 1221);
    2944           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1221);
    2945           1 :         CATCH_REQUIRE(opt.has_default("size"));
    2946           1 :         CATCH_REQUIRE(opt.get_default("size") == "193");
    2947           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    2948             : 
    2949             :         // configuration-filenames parameter
    2950           1 :         CATCH_REQUIRE(opt.get_option("configuration-filenames") != nullptr);
    2951           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("configuration-filenames"));
    2952           1 :         CATCH_REQUIRE_FALSE(opt.has_default("configuration-filenames"));
    2953           1 :         CATCH_REQUIRE(opt.get_default("configuration-filenames").empty());
    2954           1 :         CATCH_REQUIRE(opt.size("configuration-filenames") == 0);
    2955             : 
    2956             :         // other parameters
    2957           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    2958           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    2959             : 
    2960             :         // process system options now
    2961           2 :         std::stringstream ss;
    2962           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    2963           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    2964           1 :         CATCH_REQUIRE(ss.str().empty());
    2965             :     CATCH_END_SECTION()
    2966           4 : }
    2967             : 
    2968             : 
    2969             : 
    2970           5 : CATCH_TEST_CASE("system_flags_path_to_option_definitions", "[arguments][valid][getopt][system_flags]")
    2971             : {
    2972           6 :     CATCH_START_SECTION("Check with the --path-to-option-definitions system flag (Default)")
    2973             :     {
    2974           1 :         advgetopt::option const options[] =
    2975             :         {
    2976             :             advgetopt::define_option(
    2977             :                   advgetopt::Name("size")
    2978             :                 , advgetopt::ShortName('s')
    2979             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    2980             :                 , advgetopt::Help("define the size.")
    2981             :                 , advgetopt::DefaultValue("7301")
    2982             :             ),
    2983             :             advgetopt::end_options()
    2984             :         };
    2985             : 
    2986           1 :         advgetopt::options_environment environment_options;
    2987           1 :         environment_options.f_project_name = "unittest";
    2988           1 :         environment_options.f_options = options;
    2989           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    2990             : 
    2991           1 :         char const * cargv[] =
    2992             :         {
    2993             :             "/usr/bin/arguments",
    2994             :             "--path-to-option-definitions",
    2995             :             nullptr
    2996             :         };
    2997           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    2998           1 :         char ** argv = const_cast<char **>(cargv);
    2999             : 
    3000           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3001             : 
    3002             :         // check that the result is valid
    3003             : 
    3004             :         // an invalid parameter, MUST NOT EXIST
    3005           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3006           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3007           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3008           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3009           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3010             : 
    3011             :         // no default
    3012           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3013           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3014           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3015           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3016             : 
    3017             :         // valid parameter
    3018           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3019           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    3020           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3021           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    3022           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    3023           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    3024           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    3025           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    3026           1 :         CATCH_REQUIRE(opt.has_default("size"));
    3027           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    3028           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3029             : 
    3030             :         // path-to-option-definitions parameter
    3031           1 :         CATCH_REQUIRE(opt.get_option("path-to-option-definitions") != nullptr);
    3032           1 :         CATCH_REQUIRE(opt.is_defined("path-to-option-definitions"));
    3033           1 :         CATCH_REQUIRE(opt.get_string("path-to-option-definitions") == "");
    3034           1 :         CATCH_REQUIRE(opt.get_string("path-to-option-definitions", 0) == "");
    3035           1 :         CATCH_REQUIRE(opt["path-to-option-definitions"] == "");
    3036           1 :         CATCH_REQUIRE_FALSE(opt.has_default("path-to-option-definitions"));
    3037           1 :         CATCH_REQUIRE(opt.get_default("path-to-option-definitions").empty());
    3038           1 :         CATCH_REQUIRE(opt.size("path-to-option-definitions") == 1);
    3039             : 
    3040             :         // other parameters
    3041           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3042           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3043             : 
    3044             :         // process system options now
    3045           2 :         std::stringstream ss;
    3046           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    3047           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_PATH_TO_OPTION_DEFINITIONS);
    3048           1 :         CATCH_REQUIRE(ss.str() == "/usr/share/advgetopt/options/\n");
    3049             :     }
    3050             :     CATCH_END_SECTION()
    3051             : 
    3052           6 :     CATCH_START_SECTION("Check with the --path-to-option-definitions system flag (Specified)")
    3053             :     {
    3054           1 :         advgetopt::option const options[] =
    3055             :         {
    3056             :             advgetopt::define_option(
    3057             :                   advgetopt::Name("size")
    3058             :                 , advgetopt::ShortName('s')
    3059             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    3060             :                 , advgetopt::Help("define the size.")
    3061             :                 , advgetopt::DefaultValue("7301")
    3062             :             ),
    3063             :             advgetopt::end_options()
    3064             :         };
    3065             : 
    3066           1 :         advgetopt::options_environment environment_options;
    3067           1 :         environment_options.f_project_name = "unittest";
    3068           1 :         environment_options.f_options = options;
    3069           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    3070           1 :         environment_options.f_options_files_directory = "/opt/advgetopt/configs";
    3071             : 
    3072           1 :         char const * cargv[] =
    3073             :         {
    3074             :             "/usr/bin/arguments",
    3075             :             "--path-to-option-definitions",
    3076             :             nullptr
    3077             :         };
    3078           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3079           1 :         char ** argv = const_cast<char **>(cargv);
    3080             : 
    3081           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3082             : 
    3083             :         // check that the result is valid
    3084             : 
    3085             :         // an invalid parameter, MUST NOT EXIST
    3086           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3087           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3088           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3089           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3090           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3091             : 
    3092             :         // no default
    3093           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3094           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3095           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3096           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3097             : 
    3098             :         // valid parameter
    3099           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3100           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    3101           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3102           1 :         CATCH_REQUIRE(opt.get_string("size") == "7301");
    3103           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "7301");
    3104           1 :         CATCH_REQUIRE(opt["size"] == "7301");
    3105           1 :         CATCH_REQUIRE(opt.get_long("size") == 7301);
    3106           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 7301);
    3107           1 :         CATCH_REQUIRE(opt.has_default("size"));
    3108           1 :         CATCH_REQUIRE(opt.get_default("size") == "7301");
    3109           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3110             : 
    3111             :         // path-to-option-definitions parameter
    3112           1 :         CATCH_REQUIRE(opt.get_option("path-to-option-definitions") != nullptr);
    3113           1 :         CATCH_REQUIRE(opt.is_defined("path-to-option-definitions"));
    3114           1 :         CATCH_REQUIRE(opt.get_string("path-to-option-definitions") == "");
    3115           1 :         CATCH_REQUIRE(opt.get_string("path-to-option-definitions", 0) == "");
    3116           1 :         CATCH_REQUIRE(opt["path-to-option-definitions"] == "");
    3117           1 :         CATCH_REQUIRE_FALSE(opt.has_default("path-to-option-definitions"));
    3118           1 :         CATCH_REQUIRE(opt.get_default("path-to-option-definitions").empty());
    3119           1 :         CATCH_REQUIRE(opt.size("path-to-option-definitions") == 1);
    3120             : 
    3121             :         // other parameters
    3122           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3123           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3124             : 
    3125             :         // process system options now
    3126           2 :         std::stringstream ss;
    3127           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    3128           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_PATH_TO_OPTION_DEFINITIONS);
    3129           1 :         CATCH_REQUIRE(ss.str() == "/opt/advgetopt/configs/\n");
    3130             :     }
    3131             :     CATCH_END_SECTION()
    3132             : 
    3133           6 :     CATCH_START_SECTION("Check with the --path-to-option-definitions system flag, without a --path-to-option-definitions on the command line")
    3134           1 :         advgetopt::option const options[] =
    3135             :         {
    3136             :             advgetopt::define_option(
    3137             :                   advgetopt::Name("size")
    3138             :                 , advgetopt::ShortName('s')
    3139             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    3140             :                 , advgetopt::Help("define the size.")
    3141             :                 , advgetopt::DefaultValue("303")
    3142             :             ),
    3143             :             advgetopt::end_options()
    3144             :         };
    3145             : 
    3146           1 :         advgetopt::options_environment environment_options;
    3147           1 :         environment_options.f_project_name = "unittest";
    3148           1 :         environment_options.f_options = options;
    3149           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    3150           1 :         environment_options.f_help_header = "Usage: test system commands";
    3151           1 :         environment_options.f_help_footer = "Copyright matters";
    3152             : 
    3153           1 :         char const * cargv[] =
    3154             :         {
    3155             :             "/usr/bin/arguments",
    3156             :             "--size",
    3157             :             "1919",
    3158             :             nullptr
    3159             :         };
    3160           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3161           1 :         char ** argv = const_cast<char **>(cargv);
    3162             : 
    3163           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3164             : 
    3165             :         // check that the result is valid
    3166             : 
    3167             :         // an invalid parameter, MUST NOT EXIST
    3168           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3169           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3170           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3171           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3172           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3173             : 
    3174             :         // no default
    3175           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3176           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3177           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3178           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3179             : 
    3180             :         // valid parameter
    3181           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3182           1 :         CATCH_REQUIRE(opt.get_option('s') == opt.get_option("size"));
    3183           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    3184           1 :         CATCH_REQUIRE(opt.get_string("size") == "1919");
    3185           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "1919");
    3186           1 :         CATCH_REQUIRE(opt["size"] == "1919");
    3187           1 :         CATCH_REQUIRE(opt.get_long("size") == 1919);
    3188           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 1919);
    3189           1 :         CATCH_REQUIRE(opt.has_default("size"));
    3190           1 :         CATCH_REQUIRE(opt.get_default("size") == "303");
    3191           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    3192             : 
    3193             :         // environment-variable-name parameter
    3194           1 :         CATCH_REQUIRE(opt.get_option("path-to-option-definitions") != nullptr);
    3195           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("path-to-option-definitions"));
    3196           1 :         CATCH_REQUIRE_FALSE(opt.has_default("path-to-option-definitions"));
    3197           1 :         CATCH_REQUIRE(opt.get_default("path-to-option-definitions").empty());
    3198           1 :         CATCH_REQUIRE(opt.size("path-to-option-definitions") == 0);
    3199             : 
    3200             :         // other parameters
    3201           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3202           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3203             : 
    3204             :         // process system options now
    3205           2 :         std::stringstream ss;
    3206           1 :         advgetopt::flag_t const result(opt.process_system_options(ss));
    3207           1 :         CATCH_REQUIRE(result == advgetopt::SYSTEM_OPTION_NONE);
    3208           1 :         CATCH_REQUIRE(ss.str().empty());
    3209             :     CATCH_END_SECTION()
    3210           3 : }
    3211             : 
    3212             : 
    3213             : 
    3214             : 
    3215             : 
    3216             : 
    3217             : 
    3218             : 
    3219           6 : CATCH_TEST_CASE("invalid_option_name", "[arguments][invalid][getopt]")
    3220             : {
    3221           8 :     CATCH_START_SECTION("Verify that asking for the string of a non-existant option fails")
    3222           1 :         advgetopt::options_environment environment_options;
    3223           1 :         environment_options.f_project_name = "unittest";
    3224           1 :         environment_options.f_options = nullptr;
    3225           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    3226           1 :         environment_options.f_help_header = "Usage: test get_string() functions";
    3227             : 
    3228           2 :         advgetopt::getopt opt(environment_options);
    3229             : 
    3230           1 :         char const * cargv[] =
    3231             :         {
    3232             :             "tests/options-parser",
    3233             :             "--license",
    3234             :             nullptr
    3235             :         };
    3236           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3237           1 :         char ** argv = const_cast<char **>(cargv);
    3238             : 
    3239           1 :         opt.finish_parsing(argc, argv);
    3240             : 
    3241           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3242             :                   opt.get_string("non-existant")
    3243             :                 , advgetopt::getopt_logic_error
    3244             :                 , Catch::Matchers::ExceptionMessage(
    3245             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3246             : 
    3247           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3248             :                   opt.get_string("non-existant", 0)
    3249             :                 , advgetopt::getopt_logic_error
    3250             :                 , Catch::Matchers::ExceptionMessage(
    3251             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3252             : 
    3253           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3254             :                   opt.get_string("non-existant", 1)
    3255             :                 , advgetopt::getopt_logic_error
    3256             :                 , Catch::Matchers::ExceptionMessage(
    3257             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3258             :     CATCH_END_SECTION()
    3259             : 
    3260           8 :     CATCH_START_SECTION("Verify that asking for the long of a non-existant option fails")
    3261           1 :         advgetopt::options_environment environment_options;
    3262           1 :         environment_options.f_project_name = "unittest";
    3263           1 :         environment_options.f_options = nullptr;
    3264           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    3265           1 :         environment_options.f_help_header = "Usage: test get_string() functions";
    3266             : 
    3267           2 :         advgetopt::getopt opt(environment_options);
    3268             : 
    3269           1 :         char const * cargv[] =
    3270             :         {
    3271             :             "tests/options-parser",
    3272             :             "--license",
    3273             :             nullptr
    3274             :         };
    3275           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3276           1 :         char ** argv = const_cast<char **>(cargv);
    3277             : 
    3278           1 :         opt.finish_parsing(argc, argv);
    3279             : 
    3280           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3281             :                   opt.get_long("non-existant")
    3282             :                 , advgetopt::getopt_logic_error
    3283             :                 , Catch::Matchers::ExceptionMessage(
    3284             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3285             : 
    3286           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3287             :                   opt.get_long("non-existant", 0)
    3288             :                 , advgetopt::getopt_logic_error
    3289             :                 , Catch::Matchers::ExceptionMessage(
    3290             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3291             : 
    3292           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3293             :                   opt.get_long("non-existant", 1)
    3294             :                 , advgetopt::getopt_logic_error
    3295             :                 , Catch::Matchers::ExceptionMessage(
    3296             :                               "getopt_logic_error: there is no --non-existant option defined."));
    3297             :     CATCH_END_SECTION()
    3298             : 
    3299           8 :     CATCH_START_SECTION("Verify that asking for a default with an empty string fails")
    3300           1 :         advgetopt::options_environment environment_options;
    3301           1 :         environment_options.f_project_name = "unittest";
    3302           1 :         environment_options.f_options = nullptr;
    3303           1 :         environment_options.f_help_header = "Usage: test get_default() functions";
    3304             : 
    3305           2 :         advgetopt::getopt opt(environment_options);
    3306             : 
    3307           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3308             :                   opt.has_default("")
    3309             :                 , advgetopt::getopt_invalid_parameter
    3310             :                 , Catch::Matchers::ExceptionMessage(
    3311             :                               "getopt_exception: get_option() `name` argument cannot be empty."));
    3312             : 
    3313           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3314             :                   opt.has_default(std::string())
    3315             :                 , advgetopt::getopt_invalid_parameter
    3316             :                 , Catch::Matchers::ExceptionMessage(
    3317             :                               "getopt_exception: get_option() `name` argument cannot be empty."));
    3318             : 
    3319           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3320             :                   opt.get_default("")
    3321             :                 , advgetopt::getopt_invalid_parameter
    3322             :                 , Catch::Matchers::ExceptionMessage(
    3323             :                               "getopt_exception: get_option() `name` argument cannot be empty."));
    3324             : 
    3325           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3326             :                   opt.get_default(std::string())
    3327             :                 , advgetopt::getopt_invalid_parameter
    3328             :                 , Catch::Matchers::ExceptionMessage(
    3329             :                               "getopt_exception: get_option() `name` argument cannot be empty."));
    3330             :     CATCH_END_SECTION()
    3331             : 
    3332           8 :     CATCH_START_SECTION("[] operators want a valid name")
    3333           1 :         advgetopt::options_environment environment_options;
    3334           1 :         environment_options.f_project_name = "unittest";
    3335           1 :         environment_options.f_options = nullptr;
    3336           1 :         environment_options.f_environment_flags = advgetopt::GETOPT_ENVIRONMENT_FLAG_SYSTEM_PARAMETERS;
    3337           1 :         environment_options.f_help_header = "Usage: test get_default() functions";
    3338             : 
    3339           2 :         advgetopt::getopt opt(environment_options);
    3340             : 
    3341           1 :         char const * cargv[] =
    3342             :         {
    3343             :             "tests/options-parser",
    3344             :             "--license",
    3345             :             nullptr
    3346             :         };
    3347           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3348           1 :         char ** argv = const_cast<char **>(cargv);
    3349             : 
    3350           1 :         opt.finish_parsing(argc, argv);
    3351             : 
    3352           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3353             :                   opt[""]
    3354             :                 , advgetopt::getopt_logic_error
    3355             :                 , Catch::Matchers::ExceptionMessage(
    3356             :                               "getopt_logic_error: argument name cannot be empty."));
    3357             : 
    3358           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3359             :                   opt[std::string()]
    3360             :                 , advgetopt::getopt_logic_error
    3361             :                 , Catch::Matchers::ExceptionMessage(
    3362             :                               "getopt_logic_error: argument name cannot be empty."));
    3363             : 
    3364           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3365             :                   opt["g"]
    3366             :                 , advgetopt::getopt_logic_error
    3367             :                 , Catch::Matchers::ExceptionMessage(
    3368             :                               "getopt_logic_error: argument name cannot be one letter if it does not exist in operator []."));
    3369             : 
    3370           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3371             :                   opt[std::string("g")]
    3372             :                 , advgetopt::getopt_logic_error
    3373             :                 , Catch::Matchers::ExceptionMessage(
    3374             :                               "getopt_logic_error: argument name cannot be one letter if it does not exist in operator []."));
    3375             : 
    3376           1 :         advgetopt::getopt const & const_opt(opt);
    3377             : 
    3378           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3379             :                   const_opt[""]
    3380             :                 , advgetopt::getopt_logic_error
    3381             :                 , Catch::Matchers::ExceptionMessage(
    3382             :                               "getopt_logic_error: argument name cannot be empty."));
    3383             : 
    3384           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3385             :                   const_opt[std::string()]
    3386             :                 , advgetopt::getopt_logic_error
    3387             :                 , Catch::Matchers::ExceptionMessage(
    3388             :                               "getopt_logic_error: argument name cannot be empty."));
    3389             :     CATCH_END_SECTION()
    3390           4 : }
    3391             : 
    3392             : 
    3393             : 
    3394           5 : CATCH_TEST_CASE("missing_default_value", "[arguments][invalid][getopt]")
    3395             : {
    3396           6 :     CATCH_START_SECTION("Verify a string value without arguments and no default")
    3397             :     {
    3398           1 :         advgetopt::option const options[] =
    3399             :         {
    3400             :             advgetopt::define_option(
    3401             :                   advgetopt::Name("size")
    3402             :                 , advgetopt::ShortName('s')
    3403             :                 , advgetopt::Flags(advgetopt::command_flags<
    3404             :                               advgetopt::GETOPT_FLAG_REQUIRED
    3405             :                             , advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
    3406             :                 , advgetopt::Help("define the size.")
    3407             :             ),
    3408             :             advgetopt::end_options()
    3409             :         };
    3410             : 
    3411           1 :         advgetopt::options_environment environment_options;
    3412           1 :         environment_options.f_project_name = "unittest";
    3413           1 :         environment_options.f_options = options;
    3414           1 :         environment_options.f_help_header = "Usage: test get_string() functions";
    3415             : 
    3416           1 :         char const * cargv[] =
    3417             :         {
    3418             :             "/usr/bin/arguments",
    3419             :             nullptr
    3420             :         };
    3421           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3422           1 :         char ** argv = const_cast<char **>(cargv);
    3423             : 
    3424           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3425             : 
    3426             :         // check that the result is valid
    3427             : 
    3428             :         // an invalid parameter, MUST NOT EXIST
    3429           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3430           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3431           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3432           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3433           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3434             : 
    3435             :         // no default
    3436           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3437           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3438           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3439           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3440             : 
    3441             :         // the valid parameter
    3442           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3443           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3444           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3445           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3446           1 :         CATCH_REQUIRE(static_cast<advgetopt::getopt const &>(opt)["size"].empty());
    3447             : 
    3448           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3449             :                   opt.get_string("size")
    3450             :                 , advgetopt::getopt_logic_error
    3451             :                 , Catch::Matchers::ExceptionMessage(
    3452             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no default."));
    3453             : 
    3454           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3455             :                   opt.get_string("size", 0)
    3456             :                 , advgetopt::getopt_logic_error
    3457             :                 , Catch::Matchers::ExceptionMessage(
    3458             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no default."));
    3459             : 
    3460           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3461             :                   opt.get_string("size", 1)
    3462             :                 , advgetopt::getopt_logic_error
    3463             :                 , Catch::Matchers::ExceptionMessage(
    3464             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no default."));
    3465             : 
    3466             :         // these do not create an entry (even though it looks like it,
    3467             :         // i.e. it would for an std::map)
    3468             :         //
    3469           1 :         CATCH_REQUIRE(opt["size"].empty());
    3470           1 :         CATCH_REQUIRE(opt["size"].length() == 0);
    3471           1 :         CATCH_REQUIRE(opt["size"].size() == 0);
    3472             : 
    3473           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3474             : 
    3475           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3476             :                   opt.get_string("size", 0)
    3477             :                 , advgetopt::getopt_logic_error
    3478             :                 , Catch::Matchers::ExceptionMessage(
    3479             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no default."));
    3480             : 
    3481           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3482             :                   opt.get_string("size", 1)
    3483             :                 , advgetopt::getopt_logic_error
    3484             :                 , Catch::Matchers::ExceptionMessage(
    3485             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no default."));
    3486             : 
    3487             :         // now this one does create a value
    3488             :         //
    3489           1 :         opt["size"] = "45.3";
    3490             : 
    3491           1 :         CATCH_REQUIRE(opt.get_string("size") == "45.3");
    3492           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "45.3");
    3493             : 
    3494           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3495             :                   opt.get_string("size", 1)
    3496             :                 , advgetopt::getopt_undefined
    3497             :                 , Catch::Matchers::ExceptionMessage(
    3498             :                               "getopt_exception: option_info::get_value(): no value at index 1 (idx >= 1) for --size so you can't get this value."));
    3499             : 
    3500             :         // other parameters
    3501           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3502           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3503             :     }
    3504             :     CATCH_END_SECTION()
    3505             : 
    3506           6 :     CATCH_START_SECTION("Verify an integer (long) value without arguments and no default")
    3507             :     {
    3508           1 :         advgetopt::option const options[] =
    3509             :         {
    3510             :             advgetopt::define_option(
    3511             :                   advgetopt::Name("size")
    3512             :                 , advgetopt::ShortName('s')
    3513             :                 , advgetopt::Flags(advgetopt::command_flags<
    3514             :                               advgetopt::GETOPT_FLAG_REQUIRED
    3515             :                             , advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
    3516             :                 , advgetopt::Help("define the size.")
    3517             :             ),
    3518             :             advgetopt::end_options()
    3519             :         };
    3520             : 
    3521           1 :         advgetopt::options_environment environment_options;
    3522           1 :         environment_options.f_project_name = "unittest";
    3523           1 :         environment_options.f_options = options;
    3524           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
    3525             : 
    3526           1 :         char const * cargv[] =
    3527             :         {
    3528             :             "/usr/bin/arguments",
    3529             :             nullptr
    3530             :         };
    3531           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3532           1 :         char ** argv = const_cast<char **>(cargv);
    3533             : 
    3534           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3535             : 
    3536             :         // check that the result is valid
    3537             : 
    3538             :         // an invalid parameter, MUST NOT EXIST
    3539           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3540           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3541           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3542           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3543           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3544             : 
    3545             :         // no default
    3546           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3547           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3548           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3549           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3550             : 
    3551             :         // the valid parameter
    3552           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3553           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3554           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3555           1 :         CATCH_REQUIRE_FALSE(opt.has_default("size"));
    3556           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3557             : 
    3558           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3559             :                   opt.get_long("size")
    3560             :                 , advgetopt::getopt_logic_error
    3561             :                 , Catch::Matchers::ExceptionMessage(
    3562             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3563             : 
    3564           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3565             :                   opt.get_long("size", 0)
    3566             :                 , advgetopt::getopt_logic_error
    3567             :                 , Catch::Matchers::ExceptionMessage(
    3568             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3569             : 
    3570           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3571             :                   opt.get_long("size", 1)
    3572             :                 , advgetopt::getopt_logic_error
    3573             :                 , Catch::Matchers::ExceptionMessage(
    3574             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3575             : 
    3576             :         // other parameters
    3577           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3578           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3579             :     }
    3580             :     CATCH_END_SECTION()
    3581             : 
    3582           6 :     CATCH_START_SECTION("Verify an integer (long) value without arguments and an empty string as default")
    3583             :     {
    3584           1 :         advgetopt::option const options[] =
    3585             :         {
    3586             :             advgetopt::define_option(
    3587             :                   advgetopt::Name("size")
    3588             :                 , advgetopt::ShortName('s')
    3589             :                 , advgetopt::Flags(advgetopt::command_flags<
    3590             :                               advgetopt::GETOPT_FLAG_REQUIRED
    3591             :                             , advgetopt::GETOPT_FLAG_DYNAMIC_CONFIGURATION>())
    3592             :                 , advgetopt::Help("define the size.")
    3593             :                 , advgetopt::DefaultValue("")
    3594             :             ),
    3595             :             advgetopt::end_options()
    3596             :         };
    3597             : 
    3598           1 :         advgetopt::options_environment environment_options;
    3599           1 :         environment_options.f_project_name = "unittest";
    3600           1 :         environment_options.f_options = options;
    3601           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
    3602             : 
    3603           1 :         char const * cargv[] =
    3604             :         {
    3605             :             "/usr/bin/arguments",
    3606             :             nullptr
    3607             :         };
    3608           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3609           1 :         char ** argv = const_cast<char **>(cargv);
    3610             : 
    3611           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3612             : 
    3613             :         // check that the result is valid
    3614             : 
    3615             :         // an invalid parameter, MUST NOT EXIST
    3616           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3617           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3618           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3619           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3620           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3621             : 
    3622             :         // no default
    3623           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3624           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3625           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3626           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3627             : 
    3628             :         // the valid parameter
    3629           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3630           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3631           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3632           1 :         CATCH_REQUIRE(opt.has_default("size"));
    3633           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3634             : 
    3635           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3636             :                   opt.get_long("size")
    3637             :                 , advgetopt::getopt_logic_error
    3638             :                 , Catch::Matchers::ExceptionMessage(
    3639             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3640             : 
    3641           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3642             :                   opt.get_long("size", 0)
    3643             :                 , advgetopt::getopt_logic_error
    3644             :                 , Catch::Matchers::ExceptionMessage(
    3645             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3646             : 
    3647           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3648             :                   opt.get_long("size", 1)
    3649             :                 , advgetopt::getopt_logic_error
    3650             :                 , Catch::Matchers::ExceptionMessage(
    3651             :                               "getopt_logic_error: the --size option was not defined on the command line and it has no or an empty default."));
    3652             : 
    3653             :         // other parameters
    3654           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3655           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3656             :     }
    3657             :     CATCH_END_SECTION()
    3658           3 : }
    3659             : 
    3660             : 
    3661             : 
    3662           3 : CATCH_TEST_CASE("incompatible_default_value", "[arguments][invalid][getopt]")
    3663             : {
    3664           2 :     CATCH_START_SECTION("Verify an integer (long) value without arguments and a non-numeric default")
    3665           1 :         advgetopt::option const options[] =
    3666             :         {
    3667             :             advgetopt::define_option(
    3668             :                   advgetopt::Name("size")
    3669             :                 , advgetopt::ShortName('s')
    3670             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    3671             :                 , advgetopt::Help("define the size.")
    3672             :                 , advgetopt::DefaultValue("undefined")
    3673             :             ),
    3674             :             advgetopt::end_options()
    3675             :         };
    3676             : 
    3677           1 :         advgetopt::options_environment environment_options;
    3678           1 :         environment_options.f_project_name = "unittest";
    3679           1 :         environment_options.f_options = options;
    3680           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
    3681             : 
    3682           1 :         char const * cargv[] =
    3683             :         {
    3684             :             "/usr/bin/arguments",
    3685             :             nullptr
    3686             :         };
    3687           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3688           1 :         char ** argv = const_cast<char **>(cargv);
    3689             : 
    3690           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3691             : 
    3692             :         // check that the result is valid
    3693             : 
    3694             :         // an invalid parameter, MUST NOT EXIST
    3695           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3696           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3697           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3698           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3699           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3700             : 
    3701             :         // no default
    3702           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3703           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3704           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3705           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3706             : 
    3707             :         // the valid parameter
    3708           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3709           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3710           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3711           1 :         CATCH_REQUIRE(opt.has_default("size"));
    3712           1 :         CATCH_REQUIRE(opt.get_default("size") == "undefined"); // this works, it fails with get_long() though
    3713           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3714             : 
    3715           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3716             :                   opt.get_long("size")
    3717             :                 , advgetopt::getopt_logic_error
    3718             :                 , Catch::Matchers::ExceptionMessage(
    3719             :                               "getopt_logic_error: invalid default number \"undefined\" for option --size"));
    3720             : 
    3721           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3722             :                   opt.get_long("size", 0)
    3723             :                 , advgetopt::getopt_logic_error
    3724             :                 , Catch::Matchers::ExceptionMessage(
    3725             :                               "getopt_logic_error: invalid default number \"undefined\" for option --size"));
    3726             : 
    3727           1 :         CATCH_REQUIRE_THROWS_MATCHES(
    3728             :                   opt.get_long("size", 1)
    3729             :                 , advgetopt::getopt_logic_error
    3730             :                 , Catch::Matchers::ExceptionMessage(
    3731             :                               "getopt_logic_error: invalid default number \"undefined\" for option --size"));
    3732             : 
    3733             :         // other parameters
    3734           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3735           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3736             :     CATCH_END_SECTION()
    3737           1 : }
    3738             : 
    3739             : 
    3740             : 
    3741           4 : CATCH_TEST_CASE("out_of_range_value", "[arguments][invalid][getopt]")
    3742             : {
    3743           4 :     CATCH_START_SECTION("Verify an integer (long) value without arguments and a non-numeric default")
    3744           1 :         advgetopt::option const options[] =
    3745             :         {
    3746             :             advgetopt::define_option(
    3747             :                   advgetopt::Name("size")
    3748             :                 , advgetopt::ShortName('s')
    3749             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    3750             :                 , advgetopt::Help("define the size.")
    3751             :                 , advgetopt::DefaultValue("-300")
    3752             :             ),
    3753             :             advgetopt::end_options()
    3754             :         };
    3755             : 
    3756           1 :         advgetopt::options_environment environment_options;
    3757           1 :         environment_options.f_project_name = "unittest";
    3758           1 :         environment_options.f_options = options;
    3759           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
    3760             : 
    3761           1 :         char const * cargv[] =
    3762             :         {
    3763             :             "/usr/bin/arguments",
    3764             :             "--size",
    3765             :             "312",
    3766             :             nullptr
    3767             :         };
    3768           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3769           1 :         char ** argv = const_cast<char **>(cargv);
    3770             : 
    3771           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3772             : 
    3773             :         // check that the result is valid
    3774             : 
    3775             :         // an invalid parameter, MUST NOT EXIST
    3776           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3777           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3778           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3779           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3780           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3781             : 
    3782             :         // no default
    3783           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3784           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3785           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3786           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3787             : 
    3788             :         // the valid parameter
    3789           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3790           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3791           1 :         CATCH_REQUIRE(opt.is_defined("size"));
    3792           1 :         CATCH_REQUIRE(opt.get_string("size") == "312");
    3793           1 :         CATCH_REQUIRE(opt.get_string("size", 0) == "312");
    3794           1 :         CATCH_REQUIRE(opt["size"] == "312");
    3795           1 :         CATCH_REQUIRE(opt.get_long("size") == 312);
    3796           1 :         CATCH_REQUIRE(opt.get_long("size", 0) == 312);
    3797           1 :         CATCH_REQUIRE(opt.get_default("size") == "-300");
    3798           1 :         CATCH_REQUIRE(opt.size("size") == 1);
    3799             : 
    3800           1 :         SNAP_CATCH2_NAMESPACE::push_expected_log("error: 312 is out of bounds (-100..100 inclusive) in parameter --size.");
    3801           1 :         CATCH_REQUIRE(opt.get_long("size", 0, -100, 100) == -1);
    3802           1 :         SNAP_CATCH2_NAMESPACE::expected_logs_stack_is_empty();
    3803             : 
    3804             :         // other parameters
    3805           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3806           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3807             :     CATCH_END_SECTION()
    3808             : 
    3809           4 :     CATCH_START_SECTION("Verify an integer (long) value without arguments and a non-numeric default")
    3810           1 :         advgetopt::option const options[] =
    3811             :         {
    3812             :             advgetopt::define_option(
    3813             :                   advgetopt::Name("size")
    3814             :                 , advgetopt::ShortName('s')
    3815             :                 , advgetopt::Flags(advgetopt::command_flags<advgetopt::GETOPT_FLAG_REQUIRED>())
    3816             :                 , advgetopt::Help("define the size.")
    3817             :                 , advgetopt::DefaultValue("-300")
    3818             :             ),
    3819             :             advgetopt::end_options()
    3820             :         };
    3821             : 
    3822           1 :         advgetopt::options_environment environment_options;
    3823           1 :         environment_options.f_project_name = "unittest";
    3824           1 :         environment_options.f_options = options;
    3825           1 :         environment_options.f_help_header = "Usage: test get_long() functions";
    3826             : 
    3827           1 :         char const * cargv[] =
    3828             :         {
    3829             :             "/usr/bin/arguments",
    3830             :             nullptr
    3831             :         };
    3832           1 :         int const argc(sizeof(cargv) / sizeof(cargv[0]) - 1);
    3833           1 :         char ** argv = const_cast<char **>(cargv);
    3834             : 
    3835           2 :         advgetopt::getopt opt(environment_options, argc, argv);
    3836             : 
    3837             :         // check that the result is valid
    3838             : 
    3839             :         // an invalid parameter, MUST NOT EXIST
    3840           1 :         CATCH_REQUIRE(opt.get_option("invalid-parameter") == nullptr);
    3841           1 :         CATCH_REQUIRE(opt.get_option('Z') == nullptr);
    3842           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("invalid-parameter"));
    3843           1 :         CATCH_REQUIRE(opt.get_default("invalid-parameter").empty());
    3844           1 :         CATCH_REQUIRE(opt.size("invalid-parameter") == 0);
    3845             : 
    3846             :         // no default
    3847           1 :         CATCH_REQUIRE(opt.get_option("--") == nullptr);
    3848           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("--"));
    3849           1 :         CATCH_REQUIRE(opt.get_default("--").empty());
    3850           1 :         CATCH_REQUIRE(opt.size("--") == 0);
    3851             : 
    3852             :         // the valid parameter
    3853           1 :         CATCH_REQUIRE(opt.get_option("size") != nullptr);
    3854           1 :         CATCH_REQUIRE(opt.get_option('s') != nullptr);
    3855           1 :         CATCH_REQUIRE_FALSE(opt.is_defined("size"));
    3856           1 :         CATCH_REQUIRE(opt.get_default("size") == "-300");
    3857           1 :         CATCH_REQUIRE(opt.size("size") == 0);
    3858             : 
    3859           1 :         SNAP_CATCH2_NAMESPACE::push_expected_log("error: -300 is out of bounds (-100..100 inclusive) in parameter --size.");
    3860           1 :         CATCH_REQUIRE(opt.get_long("size", 0, -100, 100) == -1);
    3861           1 :         SNAP_CATCH2_NAMESPACE::expected_logs_stack_is_empty();
    3862             : 
    3863             :         // other parameters
    3864           1 :         CATCH_REQUIRE(opt.get_program_name() == "arguments");
    3865           1 :         CATCH_REQUIRE(opt.get_program_fullname() == "/usr/bin/arguments");
    3866             :     CATCH_END_SECTION()
    3867           2 : }
    3868             : 
    3869             : 
    3870           3 : CATCH_TEST_CASE("check_sanitizer", "[arguments][valid][getopt]")
    3871             : {
    3872           2 :     CATCH_START_SECTION("Check that the sanitizer is detected")
    3873             :     {
    3874             :         // when compiling the tests with coverage we turn on the sanitizer
    3875             :         // so here we should get output that show the sanitizer as being
    3876             :         // turned on; unfortunately, we can't test all cases in our current
    3877             :         // situation
    3878             :         //
    3879             : #if defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__)
    3880             :         // when running coverage or in the Sanitize version
    3881             :         //
    3882           1 :         std::string const expected(
    3883             : #ifdef __SANITIZE_ADDRESS__
    3884             :                     "The address sanitizer is compiled in.\n"
    3885             : #endif
    3886             : #ifdef __SANITIZE_THREAD__
    3887             :                     "The thread sanitizer is compiled in.\n"
    3888             : #endif
    3889           2 :             );
    3890           1 :         CATCH_REQUIRE(advgetopt::getopt::sanitizer_details() == expected);
    3891             : #else
    3892             :         // when running in Debug or Release
    3893             :         //
    3894             :         CATCH_REQUIRE(advgetopt::getopt::sanitizer_details() == "The address and thread sanitizers are not compiled in.\n");
    3895             : #endif
    3896             :     }
    3897             :     CATCH_END_SECTION()
    3898           7 : }
    3899             : 
    3900             : 
    3901             : // vim: ts=4 sw=4 et

Generated by: LCOV version 1.13