From 2db15139cb34e799aebaadf876f9d96035bc0da9 Mon Sep 17 00:00:00 2001
From: Henry Fredrick Schreiner <henry.fredrick.schreiner@cern.ch>
Date: Wed, 25 Jan 2017 17:28:39 -0500
Subject: [PATCH] Initial commit of CLI library. A few things working, but not
 much

---
 CLI.hpp       | 465 ++++++++++++++++++++++++++++++++++++++++++++++++++
 Program.hpp   | 140 +++++++++++++++
 ProgramOP.hpp | 174 +++++++++++++++++++
 try.cpp       |  20 +++
 try1.cpp      |  32 ++++
 5 files changed, 831 insertions(+)
 create mode 100644 CLI.hpp
 create mode 100644 Program.hpp
 create mode 100644 ProgramOP.hpp
 create mode 100644 try.cpp
 create mode 100644 try1.cpp

diff --git a/CLI.hpp b/CLI.hpp
new file mode 100644
index 00000000..689c5cd8
--- /dev/null
+++ b/CLI.hpp
@@ -0,0 +1,465 @@
+#pragma once
+
+#include <string>
+#include <regex>
+#include <iostream>
+#include <functional>
+#include <tuple>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+#include <type_traits>
+
+// This is unreachable outside this file; you should not use Combiner directly
+namespace {
+
+void logit(std::string output) {
+    std::cout << output << std::endl;
+}
+
+template <typename T>
+std::string join(const T& v, std::string delim = ",") {
+    std::ostringstream s;
+    for (const auto& i : v) {
+        if (&i != &v[0]) {
+            s << delim;
+        }
+        s << i;
+    }
+    return s.str();
+}
+
+
+
+
+struct Combiner {
+    int num;
+    bool positional;
+    bool required;
+    bool defaulted;
+
+    /// Can be or-ed together
+    Combiner operator | (Combiner b) const {
+        Combiner self;
+        self.num = num + b.num;
+        self.positional = positional || b.positional;
+        self.required = required || b.required;
+        self.defaulted = defaulted || b.defaulted;
+        return self;
+    }
+
+    /// Call to give the number of arguments expected on cli
+    Combiner operator() (int n) const {
+        return Combiner{n, positional, required, defaulted};
+    }
+    Combiner operator, (Combiner b) const {
+        return *this | b;
+    }
+};
+
+
+}
+
+namespace CLI {
+
+class BadNameString : public std::runtime_error {
+public:
+    BadNameString(std::string name) : runtime_error("Failed to parse: " + name) {};
+};
+
+class CallForHelp : public std::runtime_error {
+public:
+    CallForHelp() : runtime_error("Help option passed") {};
+};
+
+class ParseError : public std::runtime_error {
+public:
+    ParseError(std::string info="") : runtime_error(info) {};
+};
+
+class OptionAlreadyAdded : public std::runtime_error {
+public:
+    OptionAlreadyAdded(std::string name) : runtime_error("Already added:" + name) {};
+};
+
+
+
+const std::regex reg_split{R"regex((?:([a-zA-Z0-9]?)(?:,|$)|^)([a-zA-Z0-9][a-zA-Z0-9_\-]*)?)regex"};
+const std::regex reg_short{R"regex(-([^-])(.*))regex"};
+const std::regex reg_long{R"regex(--([^-^=][^=]*)=?(.*))regex"};
+
+
+std::tuple<std::string, std::string> split(std::string fullname) throw(BadNameString) {
+
+    std::smatch match;
+    if (std::regex_match(fullname, match, reg_split)) {
+        std::string sname = match[1];
+        std::string lname = match[2];
+        if(sname == "" and lname == "")
+            throw BadNameString("EMPTY");
+        return std::tuple<std::string, std::string>(sname, lname);
+    } else throw BadNameString(fullname);
+}
+
+const Combiner NOTHING   {0,false,false,false};
+const Combiner REQUIRED  {0,false,true, false};
+const Combiner DEFAULT   {0,false,false,true};
+const Combiner POSITIONAL{0,true, false,false};
+const Combiner ARGS      {1,false,false,false};
+
+typedef std::vector<std::vector<std::string>> results_t;
+typedef std::function<bool(results_t)> callback_t;
+
+class Option {
+public:
+protected:
+    // Config
+    std::string sname;
+    std::string lname;
+    Combiner opts;
+    std::string discription;
+    callback_t callback;
+
+    // Results
+    results_t results {};
+
+
+public:
+    Option(std::string name, std::string discription = "", Combiner opts=NOTHING, std::function<bool(results_t)> callback=[](results_t){return true;}) throw (BadNameString) :
+      opts(opts), discription(discription), callback(callback){
+        std::tie(sname, lname) = split(name);
+    }
+
+    /// Process the callback
+    bool run_callback() const {
+        return callback(results);
+    }
+
+    /// Indistinguishible options are equal
+    bool operator== (const Option& other) const {
+        if(sname=="" && other.sname=="") 
+            return lname==other.lname;
+        else if(lname=="" && other.lname=="")
+            return sname==other.sname;
+        else
+            return sname==other.sname || lname==other.lname;
+    }
+
+    std::string getName() const {
+        if(sname=="")
+            return "--" + lname;
+        else if (lname=="")
+            return "-" + sname;
+        else
+            return "-" + sname + ", --" + lname;
+    }
+
+    bool check_sname(const std::string& name) const {
+        return name == sname;
+    }
+
+    bool check_lname(const std::string& name) const {
+        return name == lname;
+    }
+
+    std::string get_sname() const {
+        return sname;
+    }
+
+    std::string get_lname() const {
+        return lname;
+    }
+
+
+    int get_num() const {
+        return opts.num;
+    }
+
+    void add_result(int r, std::string s) {
+        results.at(r).push_back(s);
+    }
+    int get_new() {
+        results.emplace_back();
+        return results.size() - 1;
+    }
+    int count() {
+        return results.size();
+    }
+
+    std::string string() const {
+        std::string val = "Option: " + getName() + "\n"
+             + "  " + discription + "\n"
+             + "  [";
+        for(const auto& item : results) {
+            if(&item!=&results[0])
+                val+="],[";
+            val += join(item);
+        }
+        val += "]";
+        return val;
+    }
+
+};
+
+/// Creates a command line program, with very few defaults.
+/** To use, create a new Program() instance with argc, argv, and a help discription. The templated
+*  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+class App {
+public:
+
+protected:
+    
+    std::string desc;
+    std::vector<Option> options;
+    std::vector<std::string> missing_options;
+    std::vector<std::string> positionals;
+
+public:
+
+    
+    /// Create a new program. Pass in the same arguments as main(), along with a help string.
+    App(std::string discription)
+        : desc(discription) {
+    }
+    
+    /// Add an option, will automatically understand the type for common types.
+    /** To use, create a variable with the expected type, and pass it in after the name.
+     * After start is called, you can use count to see if the value was passed, and
+     * the value will be initialized properly. 
+     *
+     * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `|`
+     * together. The positional options take an optional number of arguments.
+     *
+     * For example,
+     *
+     *     std::string filename
+     *     program.add_option("filename", filename, "discription of filename");
+     */
+    void add_option(
+            std::string name,           ///< The name, long,short
+            callback_t callback,        ///< The callback
+            std::string discription="", ///< Discription string
+            Combiner opts=ARGS          ///< The options (REQUIRED, DEFAULT, POSITIONAL, ARGS())
+            ) {
+
+        Option myopt{name, discription, opts, callback};
+        if(std::find(std::begin(options), std::end(options), myopt) == std::end(options))
+            options.push_back(myopt);
+        else
+            throw OptionAlreadyAdded(myopt.getName());
+
+    }
+
+    /// Add option for string
+    void add_option(
+            std::string name,           ///< The name, long,short
+            std::string &variable,      ///< The variable to set
+            std::string discription="", ///< Discription string
+            Combiner opts=ARGS          ///< The options (REQUIRED, DEFAULT, POSITIONAL, ARGS())
+            ) {
+
+        CLI::callback_t fun = [&variable](CLI::results_t res){
+            if(res.size()!=1) {
+                return false;
+            }
+            if(res[0].size()!=1) {
+                return false;
+            }
+            variable = res[0][0];
+            return true;
+        };
+
+        add_option(name, fun, discription, opts);
+    }
+
+
+    /// Add option for flag
+    void add_flag(
+            std::string name,           ///< The name, short,long
+            std::string discription=""  ///< Discription string
+            ) {
+
+        CLI::callback_t fun = [](CLI::results_t res){
+            return true;
+        };
+        
+        add_option(name, fun, discription, NOTHING);
+    }
+
+    /// Add option for flag
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, void>::type
+    add_flag(
+            std::string name,           ///< The name, short,long
+                    T  &count,              ///< A varaible holding the count
+            std::string discription=""  ///< Discription string
+            ) {
+
+        count = 0;
+        CLI::callback_t fun = [&count](CLI::results_t res){
+            count = res.size();
+            return true;
+        };
+        
+        add_option(name, fun, discription, NOTHING);
+    }
+    
+
+    /// Parses the command line - throws errors
+    void parse(int argc, char **argv) throw(CallForHelp, ParseError) {
+        std::vector<std::string> args;
+        for(int i=1; i<argc; i++)
+            args.emplace_back(argv[i]);
+        parse(args);
+    }
+
+    void parse(std::vector<std::string> args) throw(CallForHelp, ParseError) {
+        std::reverse(args.begin(), args.end());
+
+        bool positional_only = false;
+        
+        while(args.size()>0) {
+
+            if(args.back() == "--") {
+                args.pop_back();
+                positional_only = true;
+            } else if(positional_only || (!_parse_long(args) && !_parse_short(args))) {
+
+                logit("Positional: "+args.back());
+                positionals.push_back(args.back());
+                args.pop_back();
+            }
+        }
+
+        for(Option& opt : options)
+            if (opt.count() > 0) {
+                logit(opt.string());
+                if(!opt.run_callback())
+                    logit("Failed");
+            }
+
+        //TODO: Check for false callbacks
+    }
+ 
+    bool _parse_short(std::vector<std::string> &args) {
+        std::string current = args.back();
+        std::smatch match;
+
+        if(!std::regex_match(current, match, reg_short))
+            return false;
+        
+        args.pop_back();
+        std::string name = match[1];
+        std::string rest = match[2];
+
+        logit("Working on short:");
+        logit(name);
+        logit(rest);
+
+        auto op = std::find_if(std::begin(options), std::end(options), [name](const Option &v){return v.check_sname(name);});
+
+        if(op == std::end(options)) {
+            missing_options.push_back("-" + op->get_sname());
+            return true;
+        }
+
+        int vnum = op->get_new();
+        int num = op->get_num();
+        
+
+        if(rest != "" && num > 0) {
+            num--;
+            op->add_result(vnum, rest);
+            rest = "";
+        }
+
+        while(num>0) {
+            num--;
+            std::string current = args.back();
+            logit("Adding: "+current);
+            args.pop_back();
+            op->add_result(vnum,current);
+            if(args.size()==0)
+                return true;
+        }
+
+        if(rest != "") {
+            rest = "-" + rest;
+            args.push_back(rest);
+        }
+        return true;
+    }
+
+    bool _parse_long(std::vector<std::string> &args) {
+        std::string current = args.back();
+        std::smatch match;
+
+        if(!std::regex_match(current, match, reg_long))
+            return false;
+        
+        args.pop_back();
+        std::string name = match[1];
+        std::string value = match[2];
+
+
+        logit("Working on long:");
+        logit(name);
+        logit(value);
+
+        auto op = std::find_if(std::begin(options), std::end(options), [name](const Option &v){return v.check_lname(name);});
+
+        if(op == std::end(options)) {
+            missing_options.push_back("--" + op->get_lname());
+            return true;
+        }
+
+
+        int vnum = op->get_new();
+        int num = op->get_num();
+        
+
+        if(value != "") {
+            num--;
+            op->add_result(vnum, value);
+        }
+
+        while(num>0) {
+            num--;
+            std::string current = args.back();
+            args.pop_back();
+            op->add_result(vnum,current);
+            if(args.size()==0)
+                return true;
+        }
+        return true;
+    }
+
+    /// This must be called after the options are in but before the rest of the program.
+    /** Instead of throwing erros, causes the program to exit
+     * if -h or an invalid option is passed. */
+    void start(int argc, char** argv) {
+        try {
+            parse(argc, argv);
+        } catch(const CallForHelp &e) {
+            std::cout << help() << std::endl;
+            exit(0);
+        } catch(const ParseError &e) {
+            std::cerr << "ERROR:" << std::endl;
+            std::cerr << e.what() << std::endl;
+            std::cerr << help() << std::endl;
+            exit(1);
+        }
+
+    }
+
+    /// Counts the number of times the given option was passed.
+    int count(std::string name) const {
+        return 0;
+    }
+
+    std::string help() const {return "";}
+    
+    
+};
+}
diff --git a/Program.hpp b/Program.hpp
new file mode 100644
index 00000000..b2d7c097
--- /dev/null
+++ b/Program.hpp
@@ -0,0 +1,140 @@
+#pragma once
+
+#include <string>
+
+#include <boost/program_options.hpp>
+
+
+// This is unreachable outside this file; you should not use Combiner directly
+namespace {
+
+struct Combiner {
+    int positional;
+    bool required;
+    bool defaulted;
+
+    /// Can be or-ed together
+    Combiner operator | (Combiner b) const {
+        Combiner self;
+        self.positional = positional + b.positional;
+        self.required = required || b.required;
+        self.defaulted = defaulted || b.defaulted;
+        return self;
+    }
+
+    /// Call to give the number of arguments expected on cli
+    Combiner operator() (int n) const {
+        return Combiner{n, required, defaulted};
+    }
+    Combiner operator, (Combiner b) const {
+        return *this | b;
+    }
+};
+}
+
+
+
+/// Creates a command line program, with very few defaults.
+/** To use, create a new Program() instance with argc, argv, and a help description. The templated
+*  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+class Program {
+public:
+    static constexpr Combiner REQUIRED{0,true,false};
+    static constexpr Combiner DEFAULT{0,false,true};
+    static constexpr Combiner POSITIONAL{1,false,false};
+
+protected:
+    boost::program_options::options_description desc;
+    boost::program_options::positional_options_description p;
+    boost::program_options::variables_map vm;
+    
+    int argc;
+    char **argv;
+    
+    /// Parses the command line (internal function)
+    void parse() {
+        try {
+            boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
+                    .options(desc).positional(p).run(), vm);
+
+            if(vm.count("help")){
+                std::cout << desc;
+                exit(0);
+            }
+
+            boost::program_options::notify(vm);
+        } catch(const boost::program_options::error& e) {
+            std::cerr << "ERROR: " << e.what() << std::endl << std::endl; 
+            std::cerr << desc << std::endl; 
+            exit(1);
+        }
+    }
+
+    
+public:
+    
+    /// Create a new program. Pass in the same arguments as main(), along with a help string.
+    Program(int argc, char** argv, std::string discription)
+        : argc(argc), argv(argv), desc(discription) {
+        desc.add_options()
+        ("help,h", "Display this help message");
+    }
+    
+    /// Allows you to manually add options in the boost style.
+    /** Usually the specialized methods are easier, but this remains for people used to Boost and for
+     * unusual situations. */
+    boost::program_options::options_description_easy_init add_options() {
+        return desc.add_options();
+    }
+    
+    /// Add an option, will automatically understand the type for common types.
+    /** To use, create a variable with the expected type, and pass it in after the name.
+     * After start is called, you can use count to see if the value was passed, and
+     * the value will be initialized properly. 
+     *
+     * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `|`
+     * together. The positional options take an optional number of arguments.
+     *
+     * For example,
+     *
+     *     std::string filename
+     *     program.add_option("filename", filename, "description of filename");
+     */
+    template<typename T>
+    void add_option(
+            std::string name,        ///< The name, long,short
+            T &value,                ///< The value
+            std::string description, ///< Discription string
+            Combiner options         ///< The options (REQUIRED, DEFAULT, POSITIONAL)
+            ) {
+        auto po_value = boost::program_options::value<T>(&value);
+        if(options.defaulted)
+            po_value = po_value->default_value(value);
+        if(options.required)
+            po_value = po_value->required();
+        desc.add_options()(name.c_str(),po_value,description.c_str());
+        if(options.positional!=0)
+            p.add(name.c_str(), options.positional);
+    }
+    
+    /// Adds a flag style option
+    void add_option(std::string name, std::string description) {
+        desc.add_options()(name.c_str(),description.c_str());
+    }
+    
+    
+    /// This must be called after the options are in but before the rest of the program.
+    /** Calls the Boost boost::program_options initialization, causing the program to exit
+     * if -h or an invalid option is passed. */
+    void start() {
+        parse();
+    }
+
+    /// Counts the number of times the given option was passed.
+    int count(std::string name) const {
+        return vm.count(name.c_str());
+    }
+    
+    
+};
diff --git a/ProgramOP.hpp b/ProgramOP.hpp
new file mode 100644
index 00000000..e7178a04
--- /dev/null
+++ b/ProgramOP.hpp
@@ -0,0 +1,174 @@
+#pragma once
+
+#include <string>
+#include <functional>
+#include <unordered_set>
+#include <vector>
+#include <iostream>
+
+#include "optionparser.h"
+
+// This is unreachable outside this file; you should not use Combiner directly
+namespace {
+
+struct Combiner {
+    int positional;
+    bool required;
+    bool defaulted;
+
+    /// Can be or-ed together
+    Combiner operator | (Combiner b) const {
+        Combiner self;
+        self.positional = positional + b.positional;
+        self.required = required || b.required;
+        self.defaulted = defaulted || b.defaulted;
+        return self;
+    }
+
+    /// Call to give the number of arguments expected on cli
+    Combiner operator() (int n) const {
+        return Combiner{n, required, defaulted};
+    }
+};
+}
+
+/// Creates a command line program, with very few defaults.
+/** To use, create a new Program() instance with argc, argv, and a help description. The templated
+*  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+class Program {
+public:
+    static constexpr Combiner REQUIRED{0,true,false};
+    static constexpr Combiner DEFAULT{0,false,true};
+    static constexpr Combiner POSITIONAL{1,false,false};
+
+protected:
+    std::vector<option::Descriptor> usage;
+    std::vector<std::function<bool(std::vector<std::string>)>> convert; /// Number is loc+2
+    std::unordered_set<int> required;
+    std::vector<int> counts;
+    std::vector<std::string> random_name_store;
+
+    int argc;
+    char **argv;
+    
+    /// Parses the command line (internal function)
+    void parse() {
+        usage.push_back(option::Descriptor{0, 0, nullptr, nullptr, nullptr, nullptr});
+
+        option::Stats stats(usage.data(), argc, argv);
+        std::vector<option::Option> options(stats.options_max);
+        std::vector<option::Option> buffer(stats.buffer_max);
+        option::Parser parse(usage.data(), argc, argv, options.data(), buffer.data());
+
+        if(parse.error()) {
+            std::cerr << "ERROR. See usage:" << std::endl;
+            option::printUsage(std::cerr, usage.data());
+            exit(1);
+        }
+
+
+        if(options[1]){
+            option::printUsage(std::cerr, usage.data());
+            exit(0);
+        }
+
+        bool found_unk = false;
+        for (option::Option* opt = options[0]; opt; opt = opt->next()) {
+            std::cout << "Unknown option: " << opt->name << "\n";
+            found_unk = true;
+        }
+        if(found_unk)
+            exit(2);
+
+        for(int i=2; i<convert.size()+2; i++) {
+            counts.emplace_back(options[i].count());
+            if(options[i]) {
+                std::vector<std::string> opt_list;
+                for(option::Option* opt = options[i]; opt; opt = opt->next())
+                    opt_list.emplace_back(opt->arg ? opt->arg : "");
+                convert.at(i-2)(opt_list);
+            }
+        }
+    }
+    
+public:
+    
+    /// Create a new program. Pass in the same arguments as main(), along with a help string.
+    Program(int argc, char** argv, std::string description)
+        : argc(argc), argv(argv) {
+        random_name_store.emplace_back(description);
+        usage.push_back(option::Descriptor{0, 0, "", "", option::Arg::None, random_name_store.back().c_str()});
+        usage.push_back(option::Descriptor{1, 0, "h", "help", option::Arg::None, "Display usage and exit."});
+    }
+    
+    
+    /// Add an option, will automatically understand the type for common types.
+    /** To use, create a variable with the expected type, and pass it in after the name.
+     * After start is called, you can use count to see if the value was passed, and
+     * the value will be initialized properly. 
+     *
+     * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `|`
+     * together. The positional options take an optional number of arguments.
+     *
+     * For example,
+     *
+     *     std::string filename
+     *     program.add_option("filename", filename, "description of filename");
+     */
+    template<typename T>
+    void add_option(
+            std::string name,        ///< The name, long,short
+            T &value,                ///< The value
+            std::string description, ///< Description string
+            Combiner options         ///< The options (REQUIRED, DEFAULT, POSITIONAL)
+            ) {
+
+        int curr_num = convert.size();
+
+        if(options.required)
+            required.emplace(curr_num);
+
+        random_name_store.emplace_back(name);
+        random_name_store.emplace_back(description);
+
+        usage.push_back(option::Descriptor{(unsigned int) convert.size()+2, 0, "", random_name_store.at(random_name_store.size()-2).c_str(), option::Arg::Optional, random_name_store.back().c_str()});
+        add_option_internal(value);
+
+        if(options.positional!=0)
+            std::cout << "positional args not yet supported" << std::endl;
+
+
+        
+    }
+    
+    /// Adds a flag style option
+    void add_flag(std::string name, std::string description, int& flag) {
+        counts.emplace_back(0);
+        random_name_store.emplace_back(name);
+        random_name_store.emplace_back(description);
+        usage.push_back(option::Descriptor{(unsigned int) convert.size()+2, 0, "", random_name_store.at(random_name_store.size()-2).c_str(), option::Arg::None, random_name_store.back().c_str()});
+        convert.push_back([&flag](std::vector<std::string> v){flag = v.size(); return true;});
+    }
+    
+    void add_option_internal(int &val) {
+        convert.push_back([&val](std::vector<std::string> v){val = std::stoi(v.at(0)); return v.size()==1;});
+    }
+    
+    void add_option_internal(std::string &val) {
+        convert.push_back([&val](std::vector<std::string> v){val = v.at(0); return v.size()==1;});
+    }
+    /// This must be called after the options are in but before the rest of the program.
+    /** Calls the Boost boost::program_options initialization, causing the program to exit
+     * if -h or an invalid option is passed. */
+    void start() {
+        parse();
+    }
+
+    /// Counts the number of times the given option was passed.
+    int count(std::string name) const {
+        return 0;
+    }
+    
+    
+};
diff --git a/try.cpp b/try.cpp
new file mode 100644
index 00000000..066e9acd
--- /dev/null
+++ b/try.cpp
@@ -0,0 +1,20 @@
+#include "CLI.hpp"
+
+
+int main (int argc, char** argv) {
+
+    CLI::App app("K3Pi goofit fitter");
+
+    std::string file;
+    app.add_option("f,file", file, "File name");
+    
+    int count;
+    app.add_flag<int>("c,count", count, "File name");
+
+    app.parse(argc, argv);
+
+    std::cout << "Working on file: " << file << std::endl;
+    std::cout << "Working on count: " << count << std::endl;
+
+    return 0;
+}
diff --git a/try1.cpp b/try1.cpp
new file mode 100644
index 00000000..10c1ee5e
--- /dev/null
+++ b/try1.cpp
@@ -0,0 +1,32 @@
+#include "CLI.hpp"
+
+
+int main (int argc, char** argv) {
+
+    std::vector<std::string> test_strings = {"a,boo", ",coo", "d,", "Q,this-is", "s", "single"};
+
+    for(std::string name : test_strings) {
+        std::string one;
+        std::string two;
+        
+        std::tie(one, two) = CLI::split(name);
+        std::cout << one << ", " << two << std::endl;
+    }
+
+    std::vector<std::string> test_fails= {"a,,boo", "a,b,c", "ssd,sfd", "-a", "", ",", "one two"};
+
+    for(std::string name : test_fails) {
+        std::string one;
+        std::string two;
+        
+        try {
+        std::tie(one, two) = CLI::split(name);
+        std::cout << "Failed to catch: " << name << std::endl;
+        return 1;
+        } catch (const CLI::BadNameString &e) {
+            std::cout << "Hooray! Caught: " << name << std::endl;
+        }
+    }
+
+    
+}