From 226d2b38d9f118a3529741b30578bdcb82154701 Mon Sep 17 00:00:00 2001
From: Philip Top <top1@llnl.gov>
Date: Tue, 26 Nov 2019 11:29:43 -0800
Subject: [PATCH 1/3] fix some warnings generated from klocwork static analyzer

---
 include/CLI/App.hpp        |  5 +++--
 include/CLI/TypeTools.hpp  | 29 +++++++++++++++--------------
 include/CLI/Validators.hpp | 23 +++++++++++------------
 3 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index 8a58e4223..704cd5947 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -751,10 +751,11 @@ class App {
                               std::string flag_description = "") {
 
         CLI::callback_t fun = [function](const CLI::results_t &res) {
-            bool trigger;
+            bool trigger{false};
             auto result = CLI::detail::lexical_cast(res[0], trigger);
-            if(trigger)
+            if(result && trigger) {
                 function();
+            }
             return result;
         };
         return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description));
diff --git a/include/CLI/TypeTools.hpp b/include/CLI/TypeTools.hpp
index 29e86957c..d7af24f10 100644
--- a/include/CLI/TypeTools.hpp
+++ b/include/CLI/TypeTools.hpp
@@ -758,7 +758,7 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
     typename std::tuple_element<1, XC>::type v2;
     bool retval = lexical_assign<decltype(v1), decltype(v1)>(strings[0], v1);
     if(strings.size() > 1) {
-        retval &= lexical_assign<decltype(v2), decltype(v2)>(strings[1], v2);
+        retval = retval && lexical_assign<decltype(v2), decltype(v2)>(strings[1], v2);
     }
     if(retval) {
         output = T{v1, v2};
@@ -773,15 +773,17 @@ template <class T,
                           expected_count<XC>::value == expected_max_vector_size && type_count<XC>::value == 1,
                       detail::enabler> = detail::dummy>
 bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    bool retval = true;
     output.clear();
     output.reserve(strings.size());
     for(const auto &elem : strings) {
 
         output.emplace_back();
-        retval &= lexical_assign<typename T::value_type, typename XC::value_type>(elem, output.back());
+        bool retval = lexical_assign<typename T::value_type, typename XC::value_type>(elem, output.back());
+        if(!retval) {
+            return false;
+        }
     }
-    return (!output.empty()) && retval;
+    return (!output.empty());
 }
 
 /// Lexical conversion of a vector types with type size of two
@@ -791,15 +793,14 @@ template <class T,
                           expected_count<XC>::value == expected_max_vector_size && type_count<XC>::value == 2,
                       detail::enabler> = detail::dummy>
 bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    bool retval = true;
     output.clear();
     for(size_t ii = 0; ii < strings.size(); ii += 2) {
 
         typename std::tuple_element<0, typename XC::value_type>::type v1;
         typename std::tuple_element<1, typename XC::value_type>::type v2;
-        retval = lexical_assign<decltype(v1), decltype(v1)>(strings[ii], v1);
+        bool retval = lexical_assign<decltype(v1), decltype(v1)>(strings[ii], v1);
         if(strings.size() > ii + 1) {
-            retval &= lexical_assign<decltype(v2), decltype(v2)>(strings[ii + 1], v2);
+            retval = retval && lexical_assign<decltype(v2), decltype(v2)>(strings[ii + 1], v2);
         }
         if(retval) {
             output.emplace_back(v1, v2);
@@ -807,7 +808,7 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
             return false;
         }
     }
-    return (!output.empty()) && retval;
+    return (!output.empty());
 }
 
 /// Conversion to a vector type using a particular single type as the conversion type
@@ -823,7 +824,7 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
     for(const auto &elem : strings) {
 
         output.emplace_back();
-        retval &= lexical_assign<typename T::value_type, XC>(elem, output.back());
+        retval = retval && lexical_assign<typename T::value_type, XC>(elem, output.back());
     }
     return (!output.empty()) && retval;
 }
@@ -857,12 +858,12 @@ template <class T, class XC, std::size_t I>
     I<type_count<T>::value, bool>::type tuple_conversion(const std::vector<std::string> &strings, T &output) {
     bool retval = true;
     if(strings.size() > I) {
-        retval &= lexical_assign<
-            typename std::tuple_element<I, T>::type,
-            typename std::conditional<is_tuple_like<XC>::value, typename std::tuple_element<I, XC>::type, XC>::type>(
-            strings[I], std::get<I>(output));
+        retval = retval && lexical_assign<typename std::tuple_element<I, T>::type,
+                                          typename std::conditional<is_tuple_like<XC>::value,
+                                                                    typename std::tuple_element<I, XC>::type,
+                                                                    XC>::type>(strings[I], std::get<I>(output));
     }
-    retval &= tuple_conversion<T, XC, I + 1>(strings, output);
+    retval = retval && tuple_conversion<T, XC, I + 1>(strings, output);
     return retval;
 }
 
diff --git a/include/CLI/Validators.hpp b/include/CLI/Validators.hpp
index 23936b510..39b05b0a4 100644
--- a/include/CLI/Validators.hpp
+++ b/include/CLI/Validators.hpp
@@ -373,17 +373,16 @@ class IPV4Validator : public Validator {
         func_ = [](std::string &ip_addr) {
             auto result = CLI::detail::split(ip_addr, '.');
             if(result.size() != 4) {
-                return "Invalid IPV4 address must have four parts (" + ip_addr + ')';
+                return std::string("Invalid IPV4 address must have four parts (") + ip_addr + ')';
             }
             int num;
-            bool retval = true;
             for(const auto &var : result) {
-                retval &= detail::lexical_cast(var, num);
+                bool retval = detail::lexical_cast(var, num);
                 if(!retval) {
-                    return "Failed parsing number (" + var + ')';
+                    return std::string( "Failed parsing number (") + var + ')';
                 }
                 if(num < 0 || num > 255) {
-                    return "Each IP number must be between 0 and 255 " + var;
+                    return std::string("Each IP number must be between 0 and 255 ") + var;
                 }
             }
             return std::string();
@@ -398,10 +397,10 @@ class PositiveNumber : public Validator {
         func_ = [](std::string &number_str) {
             double number;
             if(!detail::lexical_cast(number_str, number)) {
-                return "Failed parsing number: (" + number_str + ')';
+                return std::string("Failed parsing number: (") + number_str + ')';
             }
             if(number <= 0) {
-                return "Number less or equal to 0: (" + number_str + ')';
+                return std::string("Number less or equal to 0: (") + number_str + ')';
             }
             return std::string();
         };
@@ -414,10 +413,10 @@ class NonNegativeNumber : public Validator {
         func_ = [](std::string &number_str) {
             double number;
             if(!detail::lexical_cast(number_str, number)) {
-                return "Failed parsing number: (" + number_str + ')';
+                return std::string("Failed parsing number: (") + number_str + ')';
             }
             if(number < 0) {
-                return "Number less than 0: (" + number_str + ')';
+                return std::string("Number less than 0: (") + number_str + ')';
             }
             return std::string();
         };
@@ -431,7 +430,7 @@ class Number : public Validator {
         func_ = [](std::string &number_str) {
             double number;
             if(!detail::lexical_cast(number_str, number)) {
-                return "Failed parsing as a number (" + number_str + ')';
+                return std::string("Failed parsing as a number (") + number_str + ')';
             }
             return std::string();
         };
@@ -482,7 +481,7 @@ class Range : public Validator {
             T val;
             bool converted = detail::lexical_cast(input, val);
             if((!converted) || (val < min || val > max))
-                return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
+                return std::string("Value ") + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
 
             return std::string();
         };
@@ -508,7 +507,7 @@ class Bound : public Validator {
             T val;
             bool converted = detail::lexical_cast(input, val);
             if(!converted) {
-                return "Value " + input + " could not be converted";
+                return std::string("Value ") + input + " could not be converted";
             }
             if(val < min)
                 input = detail::to_string(min);

From 3673b0737775c9d7b5b5918096d4d91310bab864 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Tue, 26 Nov 2019 20:54:31 -0800
Subject: [PATCH 2/3] Some more visual studio static analyzer and clang-tidy
 fixes

---
 include/CLI/Option.hpp     |   2 +-
 include/CLI/TypeTools.hpp  | 121 ++++++++++++++++++++++---------------
 include/CLI/Validators.hpp |  11 ++--
 tests/AppTest.cpp          |  23 +++----
 tests/CreationTest.cpp     |   5 +-
 tests/HelpersTest.cpp      |  12 ++--
 6 files changed, 101 insertions(+), 73 deletions(-)

diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index 4a3871b82..d1aae7470 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -715,7 +715,7 @@ class Option : public OptionBase<Option> {
     /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
     std::string get_name(bool positional = false, //<[input] Show the positional name
                          bool all_options = false //<[input] Show every option
-                         ) const {
+    ) const {
         if(get_group().empty())
             return {}; // Hidden
 
diff --git a/include/CLI/TypeTools.hpp b/include/CLI/TypeTools.hpp
index d7af24f10..1ecfa2a98 100644
--- a/include/CLI/TypeTools.hpp
+++ b/include/CLI/TypeTools.hpp
@@ -295,7 +295,7 @@ template <typename T> struct expected_count<T, typename std::enable_if<is_vector
 };
 
 // Enumeration of the different supported categorizations of objects
-enum objCategory : int {
+enum class object_category : int {
     integral_value = 2,
     unsigned_integral = 4,
     enumeration = 6,
@@ -314,14 +314,16 @@ enum objCategory : int {
 };
 
 /// some type that is not otherwise recognized
-template <typename T, typename Enable = void> struct classify_object { static constexpr objCategory value{other}; };
+template <typename T, typename Enable = void> struct classify_object {
+    static constexpr object_category value{object_category::other};
+};
 
 /// Set of overloads to classify an object according to type
 template <typename T>
 struct classify_object<T,
                        typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value &&
                                                !is_bool<T>::value && !std::is_enum<T>::value>::type> {
-    static constexpr objCategory value{integral_value};
+    static constexpr object_category value{object_category::integral_value};
 };
 
 /// Unsigned integers
@@ -329,17 +331,17 @@ template <typename T>
 struct classify_object<
     T,
     typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value && !is_bool<T>::value>::type> {
-    static constexpr objCategory value{unsigned_integral};
+    static constexpr object_category value{object_category::unsigned_integral};
 };
 
 /// Boolean values
 template <typename T> struct classify_object<T, typename std::enable_if<is_bool<T>::value>::type> {
-    static constexpr objCategory value{boolean_value};
+    static constexpr object_category value{object_category::boolean_value};
 };
 
 /// Floats
 template <typename T> struct classify_object<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
-    static constexpr objCategory value{floating_point};
+    static constexpr object_category value{object_category::floating_point};
 };
 
 /// String and similar direct assignment
@@ -348,7 +350,7 @@ struct classify_object<
     T,
     typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
                             std::is_assignable<T &, std::string>::value && !is_vector<T>::value>::type> {
-    static constexpr objCategory value{string_assignable};
+    static constexpr object_category value{object_category::string_assignable};
 };
 
 /// String and similar constructible and copy assignment
@@ -358,12 +360,12 @@ struct classify_object<
     typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
                             !std::is_assignable<T &, std::string>::value &&
                             std::is_constructible<T, std::string>::value && !is_vector<T>::value>::type> {
-    static constexpr objCategory value{string_constructible};
+    static constexpr object_category value{object_category::string_constructible};
 };
 
 /// Enumerations
 template <typename T> struct classify_object<T, typename std::enable_if<std::is_enum<T>::value>::type> {
-    static constexpr objCategory value{enumeration};
+    static constexpr object_category value{object_category::enumeration};
 };
 
 /// Handy helper to contain a bunch of checks that rule out many common types (integers, string like, floating point,
@@ -384,7 +386,7 @@ struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
                                                is_direct_constructible<T, double>::value &&
                                                is_direct_constructible<T, int>::value>::type> {
-    static constexpr objCategory value{number_constructible};
+    static constexpr object_category value{object_category::number_constructible};
 };
 
 /// Assignable from int
@@ -393,7 +395,7 @@ struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
                                                !is_direct_constructible<T, double>::value &&
                                                is_direct_constructible<T, int>::value>::type> {
-    static constexpr objCategory value{integer_constructible};
+    static constexpr object_category value{object_category::integer_constructible};
 };
 
 /// Assignable from double
@@ -402,7 +404,7 @@ struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
                                                is_direct_constructible<T, double>::value &&
                                                !is_direct_constructible<T, int>::value>::type> {
-    static constexpr objCategory value{double_constructible};
+    static constexpr object_category value{object_category::double_constructible};
 };
 
 /// Tuple type
@@ -412,12 +414,12 @@ struct classify_object<T,
                                                (is_tuple_like<T>::value && uncommon_type<T>::value &&
                                                 !is_direct_constructible<T, double>::value &&
                                                 !is_direct_constructible<T, int>::value)>::type> {
-    static constexpr objCategory value{tuple_value};
+    static constexpr object_category value{object_category::tuple_value};
 };
 
 /// Vector type
 template <typename T> struct classify_object<T, typename std::enable_if<is_vector<T>::value>::type> {
-    static constexpr objCategory value{vector_value};
+    static constexpr object_category value{object_category::vector_value};
 };
 
 // Type name print
@@ -427,48 +429,53 @@ template <typename T> struct classify_object<T, typename std::enable_if<is_vecto
 /// But this is cleaner and works better in this case
 
 template <typename T,
-          enable_if_t<classify_object<T>::value == integral_value || classify_object<T>::value == integer_constructible,
+          enable_if_t<classify_object<T>::value == object_category::integral_value ||
+                          classify_object<T>::value == object_category::integer_constructible,
                       detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "INT";
 }
 
-template <typename T, enable_if_t<classify_object<T>::value == unsigned_integral, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::unsigned_integral, detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "UINT";
 }
 
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == floating_point || classify_object<T>::value == number_constructible ||
-                    classify_object<T>::value == double_constructible,
-                detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::floating_point ||
+                          classify_object<T>::value == object_category::number_constructible ||
+                          classify_object<T>::value == object_category::double_constructible,
+                      detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "FLOAT";
 }
 
 /// Print name for enumeration types
-template <typename T, enable_if_t<classify_object<T>::value == enumeration, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::enumeration, detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "ENUM";
 }
 
 /// Print name for enumeration types
-template <typename T, enable_if_t<classify_object<T>::value == boolean_value, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::boolean_value, detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "BOOLEAN";
 }
 
 /// Print for all other types
-template <typename T, enable_if_t<classify_object<T>::value >= string_assignable, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value >= object_category::string_assignable, detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "TEXT";
 }
 
 /// Print name for single element tuple types
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 1, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count<T>::value == 1,
+                      detail::enabler> = detail::dummy>
 inline std::string type_name() {
     return type_name<typename std::tuple_element<0, T>::type>();
 }
@@ -489,9 +496,9 @@ template <typename T, std::size_t I>
 }
 
 /// Print type name for tuples with 2 or more elements
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value >= 2, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count<T>::value >= 2,
+                      detail::enabler> = detail::dummy>
 std::string type_name() {
     auto tname = std::string(1, '[') + tuple_name<T, 0>();
     tname.push_back(']');
@@ -499,7 +506,8 @@ std::string type_name() {
 }
 
 /// This one should not be used normally, since vector types print the internal type
-template <typename T, enable_if_t<classify_object<T>::value == vector_value, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::vector_value, detail::enabler> = detail::dummy>
 inline std::string type_name() {
     return type_name<typename T::value_type>();
 }
@@ -550,7 +558,8 @@ inline int64_t to_flag_value(std::string val) {
 }
 
 /// Signed integers
-template <typename T, enable_if_t<classify_object<T>::value == integral_value, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::integral_value, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     try {
         size_t n = 0;
@@ -565,7 +574,8 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Unsigned integers
-template <typename T, enable_if_t<classify_object<T>::value == unsigned_integral, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::unsigned_integral, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     if(!input.empty() && input.front() == '-')
         return false; // std::stoull happily converts negative values to junk without any errors.
@@ -583,7 +593,8 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Boolean values
-template <typename T, enable_if_t<classify_object<T>::value == boolean_value, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::boolean_value, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     try {
         auto out = to_flag_value(input);
@@ -600,7 +611,8 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Floats
-template <typename T, enable_if_t<classify_object<T>::value == floating_point, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::floating_point, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     try {
         size_t n = 0;
@@ -614,21 +626,25 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// String and similar direct assignment
-template <typename T, enable_if_t<classify_object<T>::value == string_assignable, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::string_assignable, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     output = input;
     return true;
 }
 
 /// String and similar constructible and copy assignment
-template <typename T, enable_if_t<classify_object<T>::value == string_constructible, detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::string_constructible, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     output = T(input);
     return true;
 }
 
 /// Enumerations
-template <typename T, enable_if_t<classify_object<T>::value == enumeration, detail::enabler> = detail::dummy>
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::enumeration, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     typename std::underlying_type<T>::type val;
     bool retval = detail::lexical_cast(input, val);
@@ -640,7 +656,9 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Assignable from double or int
-template <typename T, enable_if_t<classify_object<T>::value == number_constructible, detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::number_constructible, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     int val;
     if(lexical_cast(input, val)) {
@@ -657,7 +675,9 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Assignable from int
-template <typename T, enable_if_t<classify_object<T>::value == integer_constructible, detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::integer_constructible, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     int val;
     if(lexical_cast(input, val)) {
@@ -668,7 +688,9 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Assignable from double
-template <typename T, enable_if_t<classify_object<T>::value == double_constructible, detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::double_constructible, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     double val;
     if(lexical_cast(input, val)) {
@@ -679,7 +701,7 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Non-string parsable by a stream
-template <typename T, enable_if_t<classify_object<T>::value == other, detail::enabler> = detail::dummy>
+template <typename T, enable_if_t<classify_object<T>::value == object_category::other, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     static_assert(is_istreamable<T>::value,
                   "option object type must have a lexical cast overload or streaming input operator(>>) defined, if it "
@@ -688,11 +710,12 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Assign a value through lexical cast operations
-template <typename T,
-          typename XC,
-          enable_if_t<std::is_same<T, XC>::value && (classify_object<T>::value == string_assignable ||
-                                                     classify_object<T>::value == string_constructible),
-                      detail::enabler> = detail::dummy>
+template <
+    typename T,
+    typename XC,
+    enable_if_t<std::is_same<T, XC>::value && (classify_object<T>::value == object_category::string_assignable ||
+                                               classify_object<T>::value == object_category::string_constructible),
+                detail::enabler> = detail::dummy>
 bool lexical_assign(const std::string &input, T &output) {
     return lexical_cast(input, output);
 }
@@ -700,8 +723,8 @@ bool lexical_assign(const std::string &input, T &output) {
 /// Assign a value through lexical cast operations
 template <typename T,
           typename XC,
-          enable_if_t<std::is_same<T, XC>::value && classify_object<T>::value != string_assignable &&
-                          classify_object<T>::value != string_constructible,
+          enable_if_t<std::is_same<T, XC>::value && classify_object<T>::value != object_category::string_assignable &&
+                          classify_object<T>::value != object_category::string_constructible,
                       detail::enabler> = detail::dummy>
 bool lexical_assign(const std::string &input, T &output) {
     if(input.empty()) {
diff --git a/include/CLI/Validators.hpp b/include/CLI/Validators.hpp
index 39b05b0a4..20d36b4d3 100644
--- a/include/CLI/Validators.hpp
+++ b/include/CLI/Validators.hpp
@@ -379,7 +379,7 @@ class IPV4Validator : public Validator {
             for(const auto &var : result) {
                 bool retval = detail::lexical_cast(var, num);
                 if(!retval) {
-                    return std::string( "Failed parsing number (") + var + ')';
+                    return std::string("Failed parsing number (") + var + ')';
                 }
                 if(num < 0 || num > 255) {
                     return std::string("Each IP number must be between 0 and 255 ") + var;
@@ -481,7 +481,8 @@ class Range : public Validator {
             T val;
             bool converted = detail::lexical_cast(input, val);
             if((!converted) || (val < min || val > max))
-                return std::string("Value ") + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
+                return std::string("Value ") + input + " not in range " + std::to_string(min) + " to " +
+                       std::to_string(max);
 
             return std::string();
         };
@@ -942,7 +943,8 @@ class AsNumberWithUnit : public Validator {
 
             bool converted = detail::lexical_cast(input, num);
             if(!converted) {
-                throw ValidationError("Value " + input + " could not be converted to " + detail::type_name<Number>());
+                throw ValidationError(std::string("Value ") + input + " could not be converted to " +
+                                      detail::type_name<Number>());
             }
 
             if(unit.empty()) {
@@ -990,7 +992,8 @@ class AsNumberWithUnit : public Validator {
             for(auto &kv : mapping) {
                 auto s = detail::to_lower(kv.first);
                 if(lower_mapping.count(s)) {
-                    throw ValidationError("Several matching lowercase unit representations are found: " + s);
+                    throw ValidationError(std::string("Several matching lowercase unit representations are found: ") +
+                                          s);
                 }
                 lower_mapping[detail::to_lower(kv.first)] = kv.second;
             }
diff --git a/tests/AppTest.cpp b/tests/AppTest.cpp
index dfbddbbcb..60ec382a5 100644
--- a/tests/AppTest.cpp
+++ b/tests/AppTest.cpp
@@ -294,7 +294,7 @@ TEST_F(TApp, OneStringEqualVersionSingleString) {
 TEST_F(TApp, OneStringEqualVersionSingleStringQuoted) {
     std::string str;
     app.add_option("-s,--string", str);
-    app.parse("--string=\"this is my quoted string\"");
+    app.parse(R"raw(--string="this is my quoted string")raw");
     EXPECT_EQ(1u, app.count("-s"));
     EXPECT_EQ(1u, app.count("--string"));
     EXPECT_EQ(str, "this is my quoted string");
@@ -305,7 +305,7 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultiple) {
     app.add_option("-s,--string", str);
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
-    app.parse("--string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"`");
+    app.parse(R"raw(--string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"`)raw");
     EXPECT_EQ(str, "this is my quoted string");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -316,12 +316,12 @@ TEST_F(TApp, OneStringEqualVersionSingleStringEmbeddedEqual) {
     app.add_option("-s,--string", str);
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
-    app.parse("--string=\"app=\\\"test1 b\\\" test2=\\\"frogs\\\"\" -t 'qstring 2' -m=`\"quoted string\"`");
+    app.parse(R"raw(--string="app=\"test1 b\" test2=\"frogs\"" -t 'qstring 2' -m=`"quoted string"`)raw");
     EXPECT_EQ(str, "app=\"test1 b\" test2=\"frogs\"");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
 
-    app.parse("--string=\"app='test1 b' test2='frogs'\" -t 'qstring 2' -m=`\"quoted string\"`");
+    app.parse(R"raw(--string="app='test1 b' test2='frogs'" -t 'qstring 2' -m=`"quoted string"`)raw");
     EXPECT_EQ(str, "app='test1 b' test2='frogs'");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -333,12 +333,12 @@ TEST_F(TApp, OneStringEqualVersionSingleStringEmbeddedEqualWindowsStyle) {
     app.add_option("-t,--tstr", str2);
     app.add_option("--mstr", str3);
     app.allow_windows_style_options();
-    app.parse("/string:\"app:\\\"test1 b\\\" test2:\\\"frogs\\\"\" /t 'qstring 2' /mstr:`\"quoted string\"`");
+    app.parse(R"raw(/string:"app:\"test1 b\" test2:\"frogs\"" /t 'qstring 2' /mstr:`"quoted string"`)raw");
     EXPECT_EQ(str, "app:\"test1 b\" test2:\"frogs\"");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
 
-    app.parse("/string:\"app:'test1 b' test2:'frogs'\" /t 'qstring 2' /mstr:`\"quoted string\"`");
+    app.parse(R"raw(/string:"app:'test1 b' test2:'frogs'" /t 'qstring 2' /mstr:`"quoted string"`)raw");
     EXPECT_EQ(str, "app:'test1 b' test2:'frogs'");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -350,7 +350,7 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleMixedStyle) {
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
     app.allow_windows_style_options();
-    app.parse("/string:\"this is my quoted string\" /t 'qstring 2' -m=`\"quoted string\"`");
+    app.parse(R"raw(/string:"this is my quoted string" /t 'qstring 2' -m=`"quoted string"`)raw");
     EXPECT_EQ(str, "this is my quoted string");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -361,7 +361,7 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleInMiddle) {
     app.add_option("-s,--string", str);
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
-    app.parse(R"raw(--string="this is my quoted string" -t "qst\"ring 2" -m=`"quoted string"`")raw");
+    app.parse(R"raw(--string="this is my quoted string" -t "qst\"ring 2" -m=`"quoted string"`)raw");
     EXPECT_EQ(str, "this is my quoted string");
     EXPECT_EQ(str2, "qst\"ring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -384,7 +384,7 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleWithEqual) {
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
     app.add_option("-j,--jstr", str4);
-    app.parse("--string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"` --jstr=Unquoted");
+    app.parse(R"raw(--string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"` --jstr=Unquoted)raw");
     EXPECT_EQ(str, "this is my quoted string");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
@@ -397,8 +397,9 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuotedMultipleWithEqualAndProgram)
     app.add_option("-t,--tstr", str2);
     app.add_option("-m,--mstr", str3);
     app.add_option("-j,--jstr", str4);
-    app.parse("program --string=\"this is my quoted string\" -t 'qstring 2' -m=`\"quoted string\"` --jstr=Unquoted",
-              true);
+    app.parse(
+        R"raw(program --string="this is my quoted string" -t 'qstring 2' -m=`"quoted string"` --jstr=Unquoted)raw",
+        true);
     EXPECT_EQ(str, "this is my quoted string");
     EXPECT_EQ(str2, "qstring 2");
     EXPECT_EQ(str3, "\"quoted string\"");
diff --git a/tests/CreationTest.cpp b/tests/CreationTest.cpp
index 629d37c1f..dfbb65261 100644
--- a/tests/CreationTest.cpp
+++ b/tests/CreationTest.cpp
@@ -704,7 +704,7 @@ class Unstreamable {
     int x_ = -1;
 
   public:
-    Unstreamable() {}
+    Unstreamable() = default;
     int get_x() const { return x_; }
     void set_x(int x) { x_ = x; }
 };
@@ -719,7 +719,8 @@ std::istream &operator>>(std::istream &in, Unstreamable &value) {
     return in;
 }
 // these need to be different classes otherwise the definitions conflict
-static_assert(CLI::detail::is_istreamable<Unstreamable>::value, "Unstreamable type is still unstreamable");
+static_assert(CLI::detail::is_istreamable<Unstreamable>::value,
+              "Unstreamable type is still unstreamable and it should be");
 
 TEST_F(TApp, MakeUnstreamableOptions) {
     Unstreamable value;
diff --git a/tests/HelpersTest.cpp b/tests/HelpersTest.cpp
index ca54e02bd..d1e1db252 100644
--- a/tests/HelpersTest.cpp
+++ b/tests/HelpersTest.cpp
@@ -859,7 +859,7 @@ TEST(Types, TypeName) {
     EXPECT_EQ("FLOAT", vector_name);
 
     static_assert(CLI::detail::classify_object<std::pair<int, std::string>>::value ==
-                      CLI::detail::objCategory::tuple_value,
+                      CLI::detail::object_category::tuple_value,
                   "pair<int,string> does not read like a tuple");
 
     std::string pair_name = CLI::detail::type_name<std::vector<std::pair<int, std::string>>>();
@@ -869,16 +869,16 @@ TEST(Types, TypeName) {
     EXPECT_EQ("UINT", vector_name);
 
     auto vclass = CLI::detail::classify_object<std::vector<std::vector<unsigned char>>>::value;
-    EXPECT_EQ(vclass, CLI::detail::objCategory::vector_value);
+    EXPECT_EQ(vclass, CLI::detail::object_category::vector_value);
 
     auto tclass = CLI::detail::classify_object<std::tuple<double>>::value;
-    EXPECT_EQ(tclass, CLI::detail::objCategory::number_constructible);
+    EXPECT_EQ(tclass, CLI::detail::object_category::number_constructible);
 
     std::string tuple_name = CLI::detail::type_name<std::tuple<double>>();
     EXPECT_EQ("FLOAT", tuple_name);
 
     static_assert(CLI::detail::classify_object<std::tuple<int, std::string>>::value ==
-                      CLI::detail::objCategory::tuple_value,
+                      CLI::detail::object_category::tuple_value,
                   "tuple<int,string> does not read like a tuple");
     tuple_name = CLI::detail::type_name<std::tuple<int, std::string>>();
     EXPECT_EQ("[INT,TEXT]", tuple_name);
@@ -906,8 +906,8 @@ TEST(Types, TypeName) {
     EXPECT_EQ("ENUM", enum_name);
 
     vclass = CLI::detail::classify_object<std::tuple<test>>::value;
-    EXPECT_EQ(vclass, CLI::detail::objCategory::tuple_value);
-    static_assert(CLI::detail::classify_object<std::tuple<test>>::value == CLI::detail::objCategory::tuple_value,
+    EXPECT_EQ(vclass, CLI::detail::object_category::tuple_value);
+    static_assert(CLI::detail::classify_object<std::tuple<test>>::value == CLI::detail::object_category::tuple_value,
                   "tuple<test> does not classify as a tuple");
     std::string enum_name2 = CLI::detail::type_name<std::tuple<test>>();
     EXPECT_EQ("ENUM", enum_name2);

From 43dc0547460dfab67660b83132ea074c87308d97 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Tue, 26 Nov 2019 21:13:46 -0800
Subject: [PATCH 3/3] some formatting updates

---
 include/CLI/Option.hpp | 2 +-
 tests/NewParseTest.cpp | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index d1aae7470..4a3871b82 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -715,7 +715,7 @@ class Option : public OptionBase<Option> {
     /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
     std::string get_name(bool positional = false, //<[input] Show the positional name
                          bool all_options = false //<[input] Show every option
-    ) const {
+                         ) const {
         if(get_group().empty())
             return {}; // Hidden
 
diff --git a/tests/NewParseTest.cpp b/tests/NewParseTest.cpp
index 1981950b6..3aea3f0ea 100644
--- a/tests/NewParseTest.cpp
+++ b/tests/NewParseTest.cpp
@@ -198,6 +198,7 @@ TEST_F(TApp, BuiltinComplexSingleImag) {
     EXPECT_DOUBLE_EQ(0, comp.imag());
 }
 
+/// Simple class containing two strings useful for testing lexical cast and conversions
 class spair {
   public:
     spair() = default;