diff --git a/.clang-tidy b/.clang-tidy
index 9aada7a..446bcfa 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -9,7 +9,6 @@ Checks:          '-checks=-*,bugprone-*,clang-analyzer-*,cppcoreguidelines-*,rea
 
 WarningsAsErrors: ''
 HeaderFilterRegex: ''
-AnalyzeTemporaryDtors: false
 FormatStyle: none
 CheckOptions:
     - key: readability-identifier-naming.ClassCase
diff --git a/src/example/example.cpp b/src/example/example.cpp
index b463ee7..224905a 100644
--- a/src/example/example.cpp
+++ b/src/example/example.cpp
@@ -1,59 +1,59 @@
 #include <iostream>
 
 #include "options/Converters.hpp"
-#include "options/Options.hpp"
+#include "options/Parser.hpp"
 
 int main(int argc, char *argv[])
 {
     using std::cout;
     using std::endl;
 
-    Options::Options opts;
+    Options::Parser args_parser;
 
-    opts.add_flag("help", 'h', "This help is accessible via short and long option");
-    opts.add_flag("verbose", 'v', "Verbose - accessible via -v and --verbose");
-    opts.add_optional(
+    args_parser.add_flag("help", 'h', "This help is accessible via short and long option");
+    args_parser.add_flag("verbose", 'v', "Verbose - accessible via -v and --verbose");
+    args_parser.add_optional(
         "level", "Debug level, one of none, debug, error - it is checked by the validator", "none",
         [](const std::string &value) { return (value == "none" || value == "debug" || value == "error"); });
 
-    opts.add_mandatory("config", 'c', "Configuration file");
-    opts.add_optional("int", 'i', "Some small integer in range <-10..10> as checked by validator", "4",
-                      [](const std::string &value) {
-                          int32_t num = Options::as_int(value);
-                          return num >= -10 && num <= 10; // NOLINT
-                      });
-    opts.add_optional("double", 'd', "Double value > 3.0", "3.14", [](const std::string &value) {
+    args_parser.add_mandatory("config", 'c', "Configuration file");
+    args_parser.add_optional("int", 'i', "Some small integer in range <-10..10> as checked by validator", "4",
+                             [](const std::string &value) {
+                                 int32_t num = Options::as_int(value);
+                                 return num >= -10 && num <= 10; // NOLINT
+                             });
+    args_parser.add_optional("double", 'd', "Double value > 3.0", "3.14", [](const std::string &value) {
         double num = Options::as_double(value);
         return num > 3.0; // NOLINT
     });
 
-    opts.add_optional("bf", "Boolean value", "false");
-    opts.add_optional("bt", "Boolean value", "true");
+    args_parser.add_optional("bf", "Boolean value", "false");
+    args_parser.add_optional("bt", "Boolean value", "true");
 
-    if (!opts.parse(argc, argv) || opts.as_bool("help"))
+    if (!args_parser.parse(argc, argv) || args_parser.as_bool("help"))
     {
         cout << "Usage: " << argv[0] << " [options] [-- [positional arguments]]" << endl;
-        cout << opts.get_possible_options() << endl;
+        cout << args_parser.get_possible_options() << endl;
         return -1;
     }
 
     cout << std::boolalpha;
     cout << "Options:" << endl;
-    cout << " verbose : " << opts.as_bool("verbose") << endl;
-    cout << " level   : " << opts.as_string("level") << endl;
-    cout << " config  : " << opts.as_string("config") << endl;
-    cout << " int     : " << opts.as_int("int") << endl;
-    cout << " double  : " << opts.as_double("double") << endl;
-    cout << " bf      : " << opts.as_bool("bf") << endl;
-    cout << " bt      : " << opts.as_bool("bt") << endl;
+    cout << " verbose : " << args_parser.as_bool("verbose") << endl;
+    cout << " level   : " << args_parser.as_string("level") << endl;
+    cout << " config  : " << args_parser.as_string("config") << endl;
+    cout << " int     : " << args_parser.as_int("int") << endl;
+    cout << " double  : " << args_parser.as_double("double") << endl;
+    cout << " bf      : " << args_parser.as_bool("bf") << endl;
+    cout << " bt      : " << args_parser.as_bool("bt") << endl;
 
     // positional arguments are all the strings after "--" separator, for example:
     // ./example -c config_file.txt -v -- these strings are positional arguments
-    if (opts.positional_count() > 0)
+    if (args_parser.positional_count() > 0)
     {
         cout << "Positional parameters:" << endl;
-        for (size_t i = 0; i < opts.positional_count(); ++i)
-            cout << " [" << i << "]: " << opts.positional(i) << endl;
+        for (size_t i = 0; i < args_parser.positional_count(); ++i)
+            cout << " [" << i << "]: " << args_parser.positional(i) << endl;
     }
     else
         cout << "No positional parameters." << endl;
diff --git a/src/options/CMakeLists.txt b/src/options/CMakeLists.txt
index 55ea5d1..ab2e9c5 100644
--- a/src/options/CMakeLists.txt
+++ b/src/options/CMakeLists.txt
@@ -1,3 +1,3 @@
-add_library(options STATIC Converters.cpp Option.cpp Options.cpp)
+add_library(options STATIC Converters.cpp Option.cpp Parser.cpp)
 target_include_directories(options PUBLIC ..)
 target_link_libraries(options PRIVATE options_compile_flags)
diff --git a/src/options/Options.cpp b/src/options/Parser.cpp
similarity index 78%
rename from src/options/Options.cpp
rename to src/options/Parser.cpp
index d1e1673..de7c7fe 100644
--- a/src/options/Options.cpp
+++ b/src/options/Parser.cpp
@@ -5,11 +5,11 @@
 #include <vector>
 
 #include "Option.hpp"
-#include "Options.hpp"
+#include "Parser.hpp"
 
 namespace Options
 {
-    struct Options::Impl
+    struct Parser::Impl
     {
         // This will throw an exception if the option is not found.
         std::vector<Option>::const_iterator find_option_by_long_name(const std::string &name) const
@@ -52,47 +52,47 @@ namespace Options
         std::vector<std::string> _positional;
     };
 
-    Options::Options() : _impl(new Impl) {}
+    Parser::Parser() : _impl(new Impl) {}
 
-    Options::~Options()
+    Parser::~Parser()
     {
         delete _impl;
     }
 
-    void Options::add_flag(const std::string &long_name, char short_name, const std::string &description)
+    void Parser::add_flag(const std::string &long_name, char short_name, const std::string &description)
     {
         _impl->add({long_name, short_name, description});
     }
 
-    void Options::add_flag(const std::string &long_name, const std::string &description)
+    void Parser::add_flag(const std::string &long_name, const std::string &description)
     {
         add_flag(long_name, Option::SHORT_NOT_USED, description);
     }
 
-    void Options::add_optional(const std::string &long_name, char short_name, const std::string &description,
-                               const std::string &default_value, validator_t validator)
+    void Parser::add_optional(const std::string &long_name, char short_name, const std::string &description,
+                              const std::string &default_value, validator_t validator)
     {
         _impl->add({long_name, short_name, description}).set_optional(default_value).set_validator(validator);
     }
 
-    void Options::add_optional(const std::string &long_name, const std::string &description,
-                               const std::string &default_value, validator_t validator)
+    void Parser::add_optional(const std::string &long_name, const std::string &description,
+                              const std::string &default_value, validator_t validator)
     {
         add_optional(long_name, Option::SHORT_NOT_USED, description, default_value, validator);
     }
 
-    void Options::add_mandatory(const std::string &long_name, char short_name, const std::string &description,
-                                validator_t validator)
+    void Parser::add_mandatory(const std::string &long_name, char short_name, const std::string &description,
+                               validator_t validator)
     {
         _impl->add({long_name, short_name, description}).set_mandatory().set_validator(validator);
     }
 
-    void Options::add_mandatory(const std::string &long_name, const std::string &description, validator_t validator)
+    void Parser::add_mandatory(const std::string &long_name, const std::string &description, validator_t validator)
     {
         add_mandatory(long_name, Option::SHORT_NOT_USED, description, validator);
     }
 
-    bool Options::parse(int argc, const char *const *argv, int start_idx)
+    bool Parser::parse(int argc, const char *const *argv, int start_idx)
     {
         int pos = start_idx;
 
@@ -140,42 +140,42 @@ namespace Options
         return std::all_of(_impl->_options.cbegin(), _impl->_options.cend(), NON_MANDATORY_OR_FOUND);
     }
 
-    size_t Options::positional_count() const
+    size_t Parser::positional_count() const
     {
         return _impl->_positional.size();
     }
 
-    const std::string &Options::positional(size_t idx) const
+    const std::string &Parser::positional(size_t idx) const
     {
         return _impl->_positional.at(idx);
     }
 
-    int32_t Options::as_int(const std::string &name) const
+    int32_t Parser::as_int(const std::string &name) const
     {
         return _impl->find_option_by_long_name(name)->as_int();
     }
 
-    uint32_t Options::as_uint(const std::string &name) const
+    uint32_t Parser::as_uint(const std::string &name) const
     {
         return _impl->find_option_by_long_name(name)->as_uint();
     }
 
-    double Options::as_double(const std::string &name) const
+    double Parser::as_double(const std::string &name) const
     {
         return _impl->find_option_by_long_name(name)->as_double();
     }
 
-    bool Options::as_bool(const std::string &name) const
+    bool Parser::as_bool(const std::string &name) const
     {
         return _impl->find_option_by_long_name(name)->as_bool();
     }
 
-    const std::string &Options::as_string(const std::string &name) const
+    const std::string &Parser::as_string(const std::string &name) const
     {
         return _impl->find_option_by_long_name(name)->as_string();
     }
 
-    std::string Options::get_possible_options() const
+    std::string Parser::get_possible_options() const
     {
         std::stringstream sstream;
 
diff --git a/src/options/Options.hpp b/src/options/Parser.hpp
similarity index 91%
rename from src/options/Options.hpp
rename to src/options/Parser.hpp
index 89e0f8e..cdec1e2 100644
--- a/src/options/Options.hpp
+++ b/src/options/Parser.hpp
@@ -7,7 +7,7 @@
 
 namespace Options
 {
-    /* Class Options.
+    /* Class Parser.
      *
      * This class defines expected and possible options passed to the program.
      *
@@ -33,17 +33,17 @@ namespace Options
      *
      * Extensive example of how to use this class is in example/example.cpp.
      */
-    class Options
+    class Parser
     {
     public:
-        Options();
-        ~Options();
+        Parser();
+        ~Parser();
 
         // explicitly disallow copying in any form
-        Options(const Options &) = delete;
-        Options(Options &&) = delete;
-        Options &operator=(const Options &) = delete;
-        Options &operator=(Options &&) = delete;
+        Parser(const Parser &) = delete;
+        Parser(Parser &&) = delete;
+        Parser &operator=(const Parser &) = delete;
+        Parser &operator=(Parser &&) = delete;
 
         void add_flag(const std::string &long_name, char short_name, const std::string &description);
 
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 55280ef..8079fd5 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -13,5 +13,5 @@ message(STATUS "Catch2 ready")
 
 enable_testing()
 
-add_executable(${PROJECT_NAME}_tests Option_Test.cpp Options_Test.cpp)
+add_executable(${PROJECT_NAME}_tests Option_Test.cpp Parser_Test.cpp)
 target_link_libraries(${PROJECT_NAME}_tests PRIVATE options options_tests_compile_flags Catch2WithMain)
diff --git a/src/tests/Options_Test.cpp b/src/tests/Options_Test.cpp
deleted file mode 100644
index ae12aed..0000000
--- a/src/tests/Options_Test.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#include "catch2/catch_test_macros.hpp"
-
-#include "options/Options.hpp"
-
-TEST_CASE("Options")
-{
-    Options::Options options;
-
-    SECTION("Not expecting any parameters and nothing given")
-    {
-        const char *argv[] = {"prg"};
-        const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-        REQUIRE(options.parse(ARGC, argv));
-        REQUIRE(options.positional_count() == 0);
-    }
-
-    SECTION("Parsing")
-    {
-        options.add_mandatory("mode", "Operation mode. Valid are: fast, slow.",
-                              [](const std::string &value) { return (value == "fast" || value == "slow"); });
-
-        options.add_optional("opt", 'o', "Bla bla", "");
-        options.add_flag("only_long", "flag with only long option visible");
-        options.add_flag("verbose", 'v', "flag with both short and long option");
-
-        REQUIRE(options.positional_count() == 0);
-        REQUIRE_THROWS(options.positional(0) == "a");
-        REQUIRE_THROWS(options.positional(1) == "a");
-
-        SECTION("Missing mandatory")
-        {
-            const char *argv[] = {"prg", "-v"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE_FALSE(options.parse(ARGC, argv));
-        }
-
-        SECTION("Wrong mandatory")
-        {
-            const char *argv[] = {"prg", "-v", "--mode", "bla"};
-            REQUIRE_FALSE(options.parse(sizeof(argv) / sizeof(char *), argv));
-        }
-
-        SECTION("Empty mandatory")
-        {
-            const char *argv[] = {"prg", "-v", "--mode"};
-            REQUIRE_FALSE(options.parse(sizeof(argv) / sizeof(char *), argv));
-        }
-
-        SECTION("Valid mandatory")
-        {
-            const char *argv[] = {"prg", "--mode", "slow"};
-            REQUIRE(options.parse(sizeof(argv) / sizeof(char *), argv));
-
-            REQUIRE(options.as_string("mode") == "slow");
-            // the other parameters have some default values
-            REQUIRE(options.as_string("opt").empty());
-            REQUIRE_FALSE(options.as_bool("only_long"));
-            REQUIRE_FALSE(options.as_bool("verbose"));
-        }
-
-        SECTION("Option not found")
-        {
-            REQUIRE_THROWS(options.as_bool("non_existing"));
-        }
-
-        SECTION("More parameters")
-        {
-            const char *argv[] = {"prg",         "--mode", "fast",     "-o", "false",
-                                  "--only_long", "--",     "whatever", "is", "here"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-
-            REQUIRE(options.as_string("mode") == "fast");
-            REQUIRE_FALSE(options.as_bool("verbose"));
-            REQUIRE(options.as_string("opt") == "false");
-            REQUIRE(options.as_bool("opt") == false);
-            REQUIRE(options.as_bool("only_long"));
-
-            REQUIRE(options.positional_count() == 3);
-            REQUIRE(options.positional(0) == "whatever");
-            REQUIRE(options.positional(1) == "is");
-            REQUIRE(options.positional(2) == "here");
-        }
-    }
-
-    SECTION("parsing flags and optional arguments")
-    {
-        options.add_flag("verbose", "Verbose");
-        options.add_flag("debug", 'd', "Debug flag");
-
-        options.add_optional("mode", "Operating mode", "fake");
-        options.add_optional("color", 'c', "Color selection", "none");
-        options.add_optional("speed", "Speed selection", "slow",
-                             [](const std::string &value) { return value == "slow" || value == "fast"; });
-        options.add_optional("height", 'h', "Height", "low",
-                             [](const std::string &value) { return value == "low" || value == "high"; });
-
-        SECTION("no parameters")
-        {
-            const char *argv[] = {"prg"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-
-            REQUIRE_FALSE(options.as_bool("verbose"));
-            REQUIRE_FALSE(options.as_bool("debug"));
-
-            REQUIRE(options.as_string("mode") == "fake");
-            REQUIRE(options.as_string("color") == "none");
-            REQUIRE(options.as_string("speed") == "slow");
-            REQUIRE(options.as_string("height") == "low");
-        }
-
-        SECTION("setting flags")
-        {
-            const char *argv[] = {"prg", "--verbose", "-d"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-
-            REQUIRE(options.as_bool("verbose"));
-            REQUIRE(options.as_bool("debug"));
-        }
-
-        SECTION("setting optional without validator without value fails")
-        {
-            const char *argv[] = {"prg", "--mode"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE_FALSE(options.parse(ARGC, argv));
-        }
-
-        SECTION("setting optional without validator with any value is OK")
-        {
-            const char *argv[] = {"prg", "--mode", "some_mode"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-            REQUIRE(options.as_string("mode") == "some_mode");
-        }
-
-        SECTION("setting optional without validator with any value via short name is OK")
-        {
-            const char *argv[] = {"prg", "-c", "blue"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-            REQUIRE(options.as_string("color") == "blue");
-        }
-
-        SECTION("setting optional with validator with invalid value fails")
-        {
-            const char *argv[] = {"prg", "--speed", "very_fast"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE_FALSE(options.parse(ARGC, argv));
-        }
-
-        SECTION("setting optional with validator with valid value is OK")
-        {
-            const char *argv[] = {"prg", "--speed", "fast"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-            REQUIRE(options.as_string("speed") == "fast");
-        }
-
-        SECTION("setting optional with validator with invalid value via short name fails")
-        {
-            const char *argv[] = {"prg", "-h", "something"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE_FALSE(options.parse(ARGC, argv));
-        }
-
-        SECTION("setting optional with validator with valid value via short name is OK")
-        {
-            const char *argv[] = {"prg", "-h", "high"};
-            const size_t ARGC = sizeof(argv) / sizeof(char *);
-
-            REQUIRE(options.parse(ARGC, argv));
-            REQUIRE(options.as_string("height") == "high");
-        }
-    }
-}
diff --git a/src/tests/Parser_Test.cpp b/src/tests/Parser_Test.cpp
new file mode 100644
index 0000000..d5ed7fe
--- /dev/null
+++ b/src/tests/Parser_Test.cpp
@@ -0,0 +1,188 @@
+#include "catch2/catch_test_macros.hpp"
+
+#include "options/Parser.hpp"
+
+TEST_CASE("Parser")
+{
+    Options::Parser parser;
+
+    SECTION("Not expecting any parameters and nothing given")
+    {
+        const char *argv[] = {"prg"};
+        const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+        REQUIRE(parser.parse(ARGC, argv));
+        REQUIRE(parser.positional_count() == 0);
+    }
+
+    SECTION("Parsing")
+    {
+        parser.add_mandatory("mode", "Operation mode. Valid are: fast, slow.",
+                             [](const std::string &value) { return (value == "fast" || value == "slow"); });
+
+        parser.add_optional("opt", 'o', "Bla bla", "");
+        parser.add_flag("only_long", "flag with only long option visible");
+        parser.add_flag("verbose", 'v', "flag with both short and long option");
+
+        REQUIRE(parser.positional_count() == 0);
+        REQUIRE_THROWS(parser.positional(0) == "a");
+        REQUIRE_THROWS(parser.positional(1) == "a");
+
+        SECTION("Missing mandatory")
+        {
+            const char *argv[] = {"prg", "-v"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE_FALSE(parser.parse(ARGC, argv));
+        }
+
+        SECTION("Wrong mandatory")
+        {
+            const char *argv[] = {"prg", "-v", "--mode", "bla"};
+            REQUIRE_FALSE(parser.parse(sizeof(argv) / sizeof(char *), argv));
+        }
+
+        SECTION("Empty mandatory")
+        {
+            const char *argv[] = {"prg", "-v", "--mode"};
+            REQUIRE_FALSE(parser.parse(sizeof(argv) / sizeof(char *), argv));
+        }
+
+        SECTION("Valid mandatory")
+        {
+            const char *argv[] = {"prg", "--mode", "slow"};
+            REQUIRE(parser.parse(sizeof(argv) / sizeof(char *), argv));
+
+            REQUIRE(parser.as_string("mode") == "slow");
+            // the other parameters have some default values
+            REQUIRE(parser.as_string("opt").empty());
+            REQUIRE_FALSE(parser.as_bool("only_long"));
+            REQUIRE_FALSE(parser.as_bool("verbose"));
+        }
+
+        SECTION("Option not found")
+        {
+            REQUIRE_THROWS(parser.as_bool("non_existing"));
+        }
+
+        SECTION("More parameters")
+        {
+            const char *argv[] = {"prg",         "--mode", "fast",     "-o", "false",
+                                  "--only_long", "--",     "whatever", "is", "here"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+
+            REQUIRE(parser.as_string("mode") == "fast");
+            REQUIRE_FALSE(parser.as_bool("verbose"));
+            REQUIRE(parser.as_string("opt") == "false");
+            REQUIRE(parser.as_bool("opt") == false);
+            REQUIRE(parser.as_bool("only_long"));
+
+            REQUIRE(parser.positional_count() == 3);
+            REQUIRE(parser.positional(0) == "whatever");
+            REQUIRE(parser.positional(1) == "is");
+            REQUIRE(parser.positional(2) == "here");
+        }
+    }
+
+    SECTION("parsing flags and optional arguments")
+    {
+        parser.add_flag("verbose", "Verbose");
+        parser.add_flag("debug", 'd', "Debug flag");
+
+        parser.add_optional("mode", "Operating mode", "fake");
+        parser.add_optional("color", 'c', "Color selection", "none");
+        parser.add_optional("speed", "Speed selection", "slow",
+                            [](const std::string &value) { return value == "slow" || value == "fast"; });
+        parser.add_optional("height", 'h', "Height", "low",
+                            [](const std::string &value) { return value == "low" || value == "high"; });
+
+        SECTION("no parameters")
+        {
+            const char *argv[] = {"prg"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+
+            REQUIRE_FALSE(parser.as_bool("verbose"));
+            REQUIRE_FALSE(parser.as_bool("debug"));
+
+            REQUIRE(parser.as_string("mode") == "fake");
+            REQUIRE(parser.as_string("color") == "none");
+            REQUIRE(parser.as_string("speed") == "slow");
+            REQUIRE(parser.as_string("height") == "low");
+        }
+
+        SECTION("setting flags")
+        {
+            const char *argv[] = {"prg", "--verbose", "-d"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+
+            REQUIRE(parser.as_bool("verbose"));
+            REQUIRE(parser.as_bool("debug"));
+        }
+
+        SECTION("setting optional without validator without value fails")
+        {
+            const char *argv[] = {"prg", "--mode"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE_FALSE(parser.parse(ARGC, argv));
+        }
+
+        SECTION("setting optional without validator with any value is OK")
+        {
+            const char *argv[] = {"prg", "--mode", "some_mode"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+            REQUIRE(parser.as_string("mode") == "some_mode");
+        }
+
+        SECTION("setting optional without validator with any value via short name is OK")
+        {
+            const char *argv[] = {"prg", "-c", "blue"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+            REQUIRE(parser.as_string("color") == "blue");
+        }
+
+        SECTION("setting optional with validator with invalid value fails")
+        {
+            const char *argv[] = {"prg", "--speed", "very_fast"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE_FALSE(parser.parse(ARGC, argv));
+        }
+
+        SECTION("setting optional with validator with valid value is OK")
+        {
+            const char *argv[] = {"prg", "--speed", "fast"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+            REQUIRE(parser.as_string("speed") == "fast");
+        }
+
+        SECTION("setting optional with validator with invalid value via short name fails")
+        {
+            const char *argv[] = {"prg", "-h", "something"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE_FALSE(parser.parse(ARGC, argv));
+        }
+
+        SECTION("setting optional with validator with valid value via short name is OK")
+        {
+            const char *argv[] = {"prg", "-h", "high"};
+            const size_t ARGC = sizeof(argv) / sizeof(char *);
+
+            REQUIRE(parser.parse(ARGC, argv));
+            REQUIRE(parser.as_string("height") == "high");
+        }
+    }
+}