Imported libcmdopt option parsing

Makefile.am

@@ -85,6 +85,8 @@ UTIL_FILES   =		\
     noise/fractal.hpp	\
     noise/lut.cpp	\
     noise/lut.hpp	\
+    options.cpp		\
+    options.hpp		\
     platform.hpp	\
     point.cpp		\
     point.hpp		\

options.cpp

@@ -0,0 +1,537 @@
+/*
+ * This file is part of libgim.
+ *
+ * libgim is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * libgim is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with libgim.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2013 Danny Robson <danny@nerdcruft.net>
+ */
+
+
+#include "options.hpp"
+
+#include "config.h"
+
+#include <iostream>
+#include <stdexcept>
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <stdint.h>
+
+#include <stdint.h>
+#include <string.h>
+
+
+using namespace std;
+using namespace util;
+
+
+/*
+ * Generic option operations, failure or default modes
+ */
+
+
+option::option (char        _letter,
+                const char *_name,
+                const char *_desc,
+                bool        _required):
+    m_shortopt   (_letter),
+    m_longopt    (_name),
+    m_description(_desc),
+    m_required   (_required),
+    m_found      (false)
+{ reset(); }
+
+
+
+void option::execute (void) {
+    throw runtime_error(
+        "Cannot provide no value for the option '" + m_longopt + "'"
+    ); 
+}
+
+void option::execute (const string& data) {
+    assert(data.size() > 0);
+    throw runtime_error(
+        "Cannot provide a value for the option '" + m_longopt + "'"
+    );
+}
+
+
+ostream& operator<< (ostream & os, const option& opt) {
+    os  << (opt.is_required () ? " -"  : "[-" ) << opt.shortopt ()
+        << (opt.is_required () ? " \t" : "]\t") << opt.longopt  ()
+        << "\t"   << opt.description ();
+    return os;
+}
+
+
+void
+option::finish (void) {
+    if (m_required && !m_found)
+        throw runtime_error ("Required argument not found: " + m_longopt);
+}
+
+
+/*
+ * Nulloption
+ */
+
+nulloption::nulloption (char        _letter,
+                        const char *_name,
+                        const char *_desc,
+                        bool        _required):
+    option (_letter, _name, _desc, _required)
+{ ; }
+
+
+/*
+ * Present option
+ */
+
+
+presentoption::presentoption (char        _letter,
+                              const char *_name,
+                              const char *_desc,
+                              bool       *_data,
+                              bool        _required):
+    option (_letter, _name, _desc, _required),
+    m_data (_data)
+{ ; }
+
+
+void
+presentoption::execute (void) {
+    *m_data = true;
+    m_found = true;
+}
+
+
+/*
+ * bytesoption
+ */
+
+bytesoption::bytesoption (char           _letter,
+                          const char    *_name,
+                          const char    *_desc,
+                          size_t        *_data,
+                          bytestype      _type,
+                          bytesmodifier  _modifier,
+                          bool           _required):
+    valueoption<size_t> (_letter, _name, _desc, _data),
+    m_type (_type),
+    m_modifier (_modifier)
+{ ; }
+
+
+bytesoption::bytestype
+bytesoption::type_from_character (char c) {
+    switch (c) {
+        case 'e':
+        case 'E':
+            return BYTES_EXA;
+
+        case 'p':
+        case 'P':
+            return BYTES_PETA;
+
+        case 't':
+        case 'T':
+            return BYTES_TERA;
+
+        case 'g':
+        case 'G':
+            return BYTES_GIGA;
+
+        case 'm':
+        case 'M':
+            return BYTES_MEGA;
+
+        case 'k':
+        case 'K':
+            return BYTES_KILO;
+    }
+
+    throw domain_error("Invalid magnitude specifier");
+}
+
+
+void
+bytesoption::execute (const std::string& data) {
+    // We shouldn't get this far into processing with a zero sized argument,
+    // that's what the null data execute function is for.
+    assert (data.size () > 0);
+
+    size_t defaultvalue = *m_data;
+
+
+    try {
+        bytesmodifier modifier = m_modifier;
+        off_t cursor = data.size () - 1;
+
+        // Consume an optional trailing `byte' type
+        if (data[cursor] == 'B' || data[cursor] == 'b') {
+            if (--cursor < 0)
+                throw invalid_argument ("Size is too short");
+        }
+
+        // Check if we explicitly request base2
+        if (data[cursor] == 'i') {
+            modifier = BYTES_BASE2;
+            if (--cursor < 0)
+                throw invalid_argument("Size is too short");
+        }
+
+        // Determine what constant factor is needed for the raw size
+        uint64_t multiplier = 1;
+        uint64_t modifier_factor;
+        switch (modifier) {
+            case BYTES_BASE2:
+                modifier_factor = 1024;
+                break;
+
+            case BYTES_BASE10:
+                modifier_factor = 1000;
+                break;
+
+            default:
+                abort ();
+        }
+
+        // Find the difference in magnitude between what is desired, and what
+        // is specified by the user. Raise the multiplier by that magnitude.
+        bytestype specified = m_type;
+        try {
+            specified = type_from_character (data[cursor]);
+            // If the character is a digit, it just means the user skipped the 
+            // size specifier, which is ok.
+        } catch (domain_error x) {
+            if (!isdigit (data[cursor]))
+                throw invalid_argument ("Not a size");
+
+            // Falsely increment the cursor if there's no size specifier...
+            ++cursor;
+        }
+
+        // ... so that we can easily decrement the cursor without special logic
+        // after reading the specifiers.
+        --cursor;
+        assert (cursor >= 0);
+
+        multiplier = pow ((double)modifier_factor, (int)specified);
+        get_arg (data.substr(0, cursor + 1), m_data);
+        *m_data *= multiplier;
+    } catch (...) {
+        // Ensure that we haven't nuked a default value due to a half
+        // completed calculation followed by an exception.
+
+        *m_data = defaultvalue;
+        throw;
+    }
+
+    m_found = true;
+}
+
+/*
+ * Internal helper options. Print help and usage.
+ * A callback to the processor which triggers output of the help message.
+ *
+ * This should never be instanced by a user of the system. The processor will
+ * automatically adds this to its available options where needed.
+ */
+class helpoption : public option {
+    protected:
+        static const char  HELP_CHARACTER;
+        static const char *HELP_NAME;
+        static const char *HELP_DESCRIPTION;
+
+        processor * m_processor;
+
+    public:
+        helpoption (processor * _processor):
+            option (HELP_CHARACTER, HELP_NAME, HELP_DESCRIPTION, false),
+            m_processor (_processor)
+    { ; }
+
+
+        virtual void execute (void);
+        virtual void execute (const std::string& data)
+        { option::execute (data); }
+};
+
+
+const char  helpoption::HELP_CHARACTER   = 'h';
+const char *helpoption::HELP_NAME        = "help";
+const char *helpoption::HELP_DESCRIPTION =
+"display help and usage information";
+
+
+void helpoption::execute (void) {
+    m_processor->print_usage ();
+    exit (EXIT_SUCCESS);
+}
+
+
+/*
+ * Command line processing options
+ */
+
+processor::processor ()
+{ add_option (new helpoption (this)); }
+
+
+processor::~processor () {
+    for(auto i = m_options.begin(); i != m_options.end(); i++)
+        delete *i;
+}
+
+
+void processor::print_usage (void) {
+    cout << "Usage: " << m_command << " [options]" << endl;
+
+    for(list<option *>::const_iterator i = m_options.begin ();
+            i != m_options.end (); i++)
+        cout << '\t' << **i << endl;
+}
+
+
+/**
+ * Parse a single argument in short form. We are given an offset into the
+ * argument array, and arguments. Establishes whether a value is present and
+ * passes control over to the option.
+ *
+ * The format of the options are "-f [b]" || "-abcde"
+ *
+ * @param pos   the current offset into the argument array
+ * @param argc  the size of the argument array
+ * @param argv  the argument array given to the application
+ *
+ * @return the number of tokens consumed for this option; must be at least 1.
+ */
+unsigned int processor::parse_short (int pos, int argc, const char ** argv) {
+    assert (pos > 0);
+    assert (pos < argc);
+
+    assert (argv[pos] != NULL);
+    const char * arg = argv[pos];
+
+    // Must begin with a dash, then have at least one non-dash character
+    assert (arg[0] == '-');
+    assert (arg[1] != '-');
+    assert (strlen(arg) >= 2);
+
+    // Check if we have a value option, Ie `-a [val]`
+    //  First: must be of form '-[a-zA-Z]'.
+    if (strlen (arg) == 2) {
+        // Second: the next segment (which contains the value) shouldn't begin
+        // with a dash.
+        if (pos + 1 < argc && argv[pos+1][0] != '-') {
+            option * o = m_shortopt[arg[1]];
+            if (!o)
+                throw runtime_error ("Cannot match option");
+
+            o->execute (argv[pos+1]);
+            return 2;
+        }
+    }
+
+    // We must have a string of no-value flags, `-abcdef...`, execute each
+    // option in the list after the dash.
+    for(unsigned int i = 1; i < strlen (arg); ++i) {
+        option * o = m_shortopt[arg[i]];
+
+        if (!o)
+            throw runtime_error ("Cannot match option");
+        o->execute ();
+    }
+
+    return 1;
+}
+
+
+/**
+ * Parse a single argument in long form. We are given an offset into the
+ * argument array, and arguments. Establishes whether a value is present and
+ * passes control over to the option. 
+ *
+ * The format of the options are "--foo[=bar]"
+ *
+ * @param pos   the current offset into the argument array
+ * @param argc  the size of the argument array
+ * @param argv  the argument array given to the application`--foo[=bar]`
+ *
+ * @return the number of tokens consumed for this option; must be 1.
+ */
+unsigned int processor::parse_long (int pos, int argc, const char ** argv) {
+    assert (pos > 0);
+    assert (pos < argc);
+
+    assert (argv[pos] != NULL);
+    const char * arg = argv[pos];
+
+    // We must have at least two hyphens, and two letters (else a short opt)
+    assert (arg[0] == '-');
+    assert (arg[1] == '-');
+    assert (strlen(arg) >= 4);
+
+    // Skip past the dashes to the argument name
+    arg += 2;
+
+    // If there's an equals it's has a value to extract
+    const char * data = strchr (arg, '=');
+    if( data) {
+        arg = strndup (arg, data - arg); // Copy just the arg name
+        data++;                          // Skip the '='
+    }
+
+    option * o = m_longopt[arg];
+    if (!o) 
+        throw runtime_error ("Cannot match option");
+
+    if(data)
+        o->execute (data); 
+    else
+        o->execute ();
+
+    return 1;
+}
+
+
+/**
+ * Pass long and short options to specific parsing handlers.
+ *
+ * Establishes enough context to determine if the argument is long, short, or
+ * none. The functions parse_long and parse_short are given the task of
+ * dispatching control to the relevant option handlers.
+ *
+ * @param argc the raw parameter from the application main
+ * @param argv the raw parameter from the application main
+ */
+
+void
+processor::parse_args (int argc, const char ** argv) {
+    // While technically we can have zero arguments, for practical purposes
+    // this is a reasonable method at catching odd errors in the library.
+    assert (argc > 0);
+    assert (argv[0]);
+
+    m_command.assign (argv[0]);
+
+    // Must make sure each option has a chance to reset state (clear flags,
+    // etc) between parses
+    for(auto i = m_options.begin (); i != m_options.end (); i++)
+        (*i)->reset ();
+
+    const unsigned int FIRST_ARGUMENT = 1;
+    try {
+        for (int i = FIRST_ARGUMENT; i < argc; ++i) {
+            // An argument must begin with a dash, if not we've reached the
+            // end of the argument lists or we have a parsing error.
+            if (argv[i][0] != '-')
+                return;
+
+            // An argument must consist of at least one non-dash character
+            if (strlen (argv[i]) <= 1)
+                throw runtime_error ("Invalid argument");
+
+            // Actually hand off args to be parsed. Subtract one from the 
+            // tokens consumed, as the for loop increments tokens too.
+            unsigned int consumed;
+            if (argv[i][1] != '-') 
+                consumed = parse_short (i, argc, argv);
+            else 
+                consumed =  parse_long (i, argc, argv);
+
+            assert (consumed >= 1);
+            i += consumed - 1;
+        }
+    } catch (runtime_error &x) {
+        print_usage ();
+        exit (EXIT_FAILURE);
+    }
+
+    for (auto i = m_options.begin (); i != m_options.end (); ++i)
+        (*i)->finish ();
+}
+
+
+void processor::add_option (option * opt) {
+    if (m_shortopt.find (opt->shortopt ()) != m_shortopt.end ())
+        throw logic_error ("Short option already exists");
+    if (m_longopt.find (opt->longopt   ()) != m_longopt.end ())
+        throw logic_error ("Long option already exists");
+
+    m_shortopt[opt->shortopt ()] = opt;
+    m_longopt [opt->longopt  ()] = opt;
+
+    m_options.push_back( opt);
+}
+
+
+option* processor::remove_option (char letter) {
+    // Locate the option by short name
+    std::map<char, option*>::iterator s_candidate = m_shortopt.find (letter);
+
+    if (s_candidate == m_shortopt.end ())
+        throw logic_error ("Cannot remove an option which is not present");
+    option * opt = (*s_candidate).second;
+
+    // Locate the long option entry
+    std::map<string, option*>::iterator l_candidate = m_longopt.find (opt->longopt ());
+    assert (l_candidate != m_longopt.end ());
+
+    // Remove all references and return
+    m_shortopt.erase (s_candidate);
+    m_longopt.erase (l_candidate);
+    m_options.remove (opt);
+
+    return opt;
+}
+
+
+option* processor::remove_option (const char * name) {
+    // Locate the option by long name
+    std::map<string, option*>::iterator l_candidate = m_longopt.find (name);
+
+    if (l_candidate == m_longopt.end ())
+        throw logic_error ("Cannot remove an option which is not present");
+    option * opt = (*l_candidate).second;
+
+    // Locate the short option entry
+    std::map<char, option*>::iterator s_candidate = m_shortopt.find (opt->shortopt ());
+    assert (s_candidate != m_shortopt.end ());
+
+    // Remove all references and return the option object
+    m_shortopt.erase (s_candidate);
+    m_longopt.erase (l_candidate);
+    m_options.remove (opt);
+
+    return opt;
+}
+
+
+/* Parse args from a stream, one arg per line
+*/
+void parse_stream (std::istream & is) {
+    char * buffer = new char[MAX_CHUNK_LENGTH + 1];
+    try {
+
+    } catch (...) {
+        delete [] buffer;
+        throw;
+    }
+}
+

options.hpp

@@ -0,0 +1,323 @@
+/*
+ * This file is part of libgim.
+ *
+ * libgim is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * libgim is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with libgim.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2013 Danny Robson <danny@nerdcruft.net>
+ */
+
+
+#ifndef __UTIL_OPTIONS_HPP
+#define __UTIL_OPTIONS_HPP
+
+#include <iostream>
+#include <list>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+
+
+/**
+ * Maximum length of an option, its value, and any supplementary characters
+ * required for interpreting them. Ie, strlen("--foo=bar")
+ */
+const size_t MAX_CHUNK_LENGTH = 1023;
+
+namespace util {
+    /**
+     * The generic base class for all options.
+     *
+     * Stores enough information to determine whether a short or long style option
+     * has been specified. The `execute' methods performs an action if the option
+     * is either present, or present with a value.
+     *
+     * By default they will throw an exception and can be relied upon to provide
+     * some form of abort action.
+     */
+    class option {
+            protected:
+                    char              m_shortopt;
+                    const std::string m_longopt;
+                    const std::string m_description;
+                    bool              m_required;
+                    bool              m_found;
+
+            public:
+                    option (char        _letter,
+                            const char *_name,
+                            const char *_desc,
+                            bool        _required);
+
+                    virtual ~option() { ; }
+
+                    virtual void execute (void) = 0;
+                    virtual void execute (const std::string& _data) = 0;
+                    virtual void finish  (void);
+
+                    virtual bool is_required (void) const
+                        { return m_required; }
+
+                    virtual void reset(void)
+                        { m_found = false; }
+
+                    virtual char shortopt(void) const
+                        { return m_shortopt; }
+                    virtual const std::string& longopt(void) const
+                        { return m_longopt; }
+                    virtual const std::string& description(void) const
+                        { return m_description; }
+    };
+
+
+    /**
+     * Specifies a debugging or deprecated option.
+     *
+     * The option will be recognised but no action will be performed when
+     * encountered. A description will still be visible when usage information is
+     * printed.
+     */
+    class nulloption : public option {
+        public:
+            nulloption(char        _letter,
+                    const char *_name,
+                    const char *_desc,
+                    bool        _required = false);
+
+            virtual void execute(void)
+                { m_found = true; }
+            virtual void execute(const std::string&)
+                { m_found = true; }
+    };
+
+
+    /**
+     * Sets a boolean value to reflect if the option has been specified.
+     *
+     * A provided boolean pointer will be set to false if the option isn't
+     * present, true if present.
+     * Assumes that the user will not modify the value for the duration of option
+     * processing.
+     * Throws an exception if a value is specified for the option.
+     */
+    class presentoption : public option {
+        protected:
+            bool *m_data;
+
+        public:
+            presentoption(char        _letter,
+                          const char *_name,
+                          const char *_desc,
+                          bool       *_data,
+                          bool        _required = false);
+
+            virtual void execute(void);
+            virtual void execute(const std::string& data)
+                { option::execute(data); }
+
+            virtual void reset(void)
+                { *m_data = false; }
+    };
+
+
+    /**
+     * Parses a value given on the command line into a specified type.
+     *
+     * Given a value, return it to the user via the specified pointer. Uses the
+     * istream operators to read the value, so it should be relatively generic.
+     * If the value is malformed then an exception will be thrown.
+     * If there is no value, then perform the default action.
+     *
+     * It is safe to assume that when no value has been extracted the data pointer
+     * provided will not be overwritten. Useful for pre-loading with default
+     * values.
+     */
+    template<typename T>
+    class valueoption : public option {
+        protected:
+            T *m_data;
+
+        public:
+            valueoption(char        _letter,
+                        const char *_name,
+                        const char *_desc,
+                        T          *_data,
+                        bool        _required = false):
+                option (_letter, _name, _desc, _required),
+                m_data (_data)
+            { ; }
+
+            virtual void execute(void) 
+                { option::execute(); }
+            virtual void execute(const std::string& data) {
+                get_arg(data, m_data);
+                m_found = true;
+            }
+
+        protected:
+            // Retrieve string to value conversion
+            T& get_arg(const std::string &arg,
+                       T                 *val) {
+                std::istringstream stream (arg, std::istringstream::in);
+                stream.exceptions (
+                      std::istringstream::failbit
+                    | std::istringstream::badbit
+                );
+                stream >> *val;
+
+                return *val;
+            }
+
+            T& get_arg(const std::string &_arg,
+                       T                 *val,
+                       const T           &defaultval) {
+                try {
+                    return get_arg(_arg, val);
+                } catch(...) {
+                    return *val = defaultval;
+                }
+            }
+
+    };
+
+
+    // God-damn Solaris strikes again with its antiquated everything. So you
+    // don't get these goodies on that system, with its ancient compiler.
+#if __GNUC__ >= 4
+    template<>
+    bool& valueoption<bool>::get_arg(const std::string& arg, bool * val) {
+        if      (arg == "true"  || arg == "yes" || arg == "1")
+            *val = true;
+        else if (arg == "false" || arg == "no"  || arg == "0")
+            *val = false;
+        else
+            throw std::domain_error("Invalid form for boolean argument");
+        
+        return *val;
+    }
+#endif
+
+
+    /**
+     * Interpret a (possibly) numeric value as a data size.
+     *
+     * A developer specifies the default scale of the value and what base it is
+     * to be interpreted in - when not otherwise explicitly stated in the
+     * arguments.
+     *
+     * Recognises various postfixes and modifiers to a numeric value such as MiB.
+     */
+    class bytesoption : public valueoption<size_t> {
+        public:
+            /* Description of types available for parsing
+            */
+            enum bytestype {
+                BYTES_SINGLE,
+                BYTES_KILO,
+                BYTES_MEGA,
+                BYTES_GIGA,
+                BYTES_TERA,
+                BYTES_PETA,
+                BYTES_EXA,
+
+                // Currently does not support yota or zeta as there can be
+                // trouble converting them without loss into 64bit quantities.
+                // That and they're fricking huge...
+                //
+                // BYTES_ZETA,
+                // BYTES_YOTA,
+
+                NUM_BYTESTYPE
+            };
+
+            enum bytesmodifier {
+                BYTES_BASE2,
+                BYTES_BASE10,
+
+                NUM_BYTESMODIFIER
+            };
+
+        protected:
+            bytestype m_type;
+            bytesmodifier m_modifier;
+
+            static bytestype type_from_character(char c);
+
+
+        public:
+            /* Constructors and methods
+            */
+            bytesoption(char           _letter,
+                        const char    *_name,
+                        const char    *_desc,
+                        size_t        *_data,
+                        bytestype      _type     = BYTES_SINGLE,
+                        bytesmodifier  _modifier = BYTES_BASE2,
+                        bool           _required = false);
+
+            virtual void execute(const std::string &);
+    };
+
+
+    /**
+     * High level handler for option registration, dispatch, and interpretation.
+     *
+     * The processor is the central point of operation on a program's arguments.
+     * It contains a list of all options which will interpret and act upon any
+     * arguments. These must be registered by the user prior to argument parsing,
+     * each of which must be primed with data to act upon separately.
+     *
+     * parse_args will perform minimal interpretation of the arguments to allow
+     * dispatch to registered options. No direct actions upon any input is
+     * performed within this class, merely dispatch and tokenisation. 
+     */
+    class processor {
+        protected:
+            std::map<char, option *> m_shortopt;
+            std::map<std::string, option *> m_longopt;
+
+            std::list<option *> m_options;
+
+            // The command to execute the application
+            std::string m_command;
+
+        protected:
+            unsigned int parse_short(int pos, int argc, const char ** argv);
+            unsigned int parse_long(int pos, int argc, const char ** argv);
+
+        public:
+            processor();
+            ~processor();
+
+            void print_usage(void);
+
+            // TODO: Use function overloading here...
+            void parse_args(int argc, const char ** argv);
+            void parse_args(int argc, char ** argv)
+                { parse_args(argc, const_cast<const char**>(argv)); }
+            void parse_stream(std::istream & is);
+
+
+            void add_option(option * opt);
+
+            option* remove_option(char letter);
+            option* remove_option(const char * name);
+            option* remove_option(const std::string& name)
+                { return remove_option(name.c_str()); }
+            option* remove_option(const option * opt)
+                { return remove_option(opt->longopt ()); }
+    };
+}
+
+
+#endif

test/.gitignore

@@ -1,3 +1,5 @@
+/*.log
+/*.trs
 /adler*
 /backtrace*
 /checksum*
@@ -7,6 +9,7 @@
 /json-check*
 /maths*
 /matrix*
+/option
 /pool*
 /range*
 /signal*

test/Makefile.am

@@ -16,6 +16,7 @@ TEST_BIN = 		\
 	json		\
 	maths 		\
 	matrix 		\
+	option		\
 	pool		\
 	range 		\
 	region		\
@@ -51,6 +52,9 @@ maths_SOURCES      = maths.cpp
 matrix_LDADD       = $(builddir)/../libutil.la
 matrix_SOURCES     = matrix.cpp
 
+option_LDADD	   = $(builddir)/../libutil.la
+option_SOURCES     = options/success.cpp
+
 pool_LDADD         = $(builddir)/../libutil.la
 pool_SOURCES	   = pool.cpp
 

test/options/success.cpp

@@ -0,0 +1,253 @@
+#include "options.hpp"
+
+#include "debug.hpp"
+#include "types.hpp"
+
+#include <cassert>
+#include <cstdlib>
+#include <string>
+#include <stdexcept>
+#include <limits>
+#include <sstream>
+#include <cstdint>
+#include <memory>
+
+
+using namespace std;
+using namespace util;
+
+
+// Check that null options don't throw anything
+void test_null_opt(void) {
+    unique_ptr<processor> p(new processor());
+
+    p->add_option(new nulloption('n', "null", "testing null option"));
+
+    const char * argv1[] = { "./foo", "-n", "foo" };
+    p->parse_args(elems(argv1), argv1);
+
+    const char * argv2[] = { "./foo", "--null", "foo" };
+    p->parse_args(elems(argv2), argv2);
+}
+
+
+
+
+// Check if presence options can be used successfully
+void test_present_opt(void) {
+    unique_ptr<processor> p(new processor());
+    bool is_present;
+    p->add_option(new presentoption('p', "present", "option is present", &is_present));
+
+    // Short option form
+    const char * argv1[] = { "./foo", "-p" };
+    is_present = false;
+    p->parse_args(elems(argv1), argv1);
+    CHECK (is_present);
+
+    // Long option form
+    const char * argv2[] = { "./foo", "--present" };
+    is_present = false;
+    p->parse_args(elems(argv2), argv2);
+    CHECK (is_present);
+
+    // Check that value is reset from true if not present
+    const char * argv3[] = { "./foo" };
+    is_present = true;
+    p->parse_args(elems(argv3), argv3);
+    CHECK (!is_present);
+}
+
+
+// Check all forms of boolean inputs
+void test_bool_opt(void) {
+    unique_ptr<processor> p(new processor());
+    bool value = false;
+
+    p->add_option(new valueoption<bool>('b', "bool",
+                "testing boolean actions", &value));
+
+    // List all legal forms of positive or negative boolean values
+    const char * argv[] = { "./foo", "-b", NULL };
+    const char * positive[] = { "1", "true", "yes" };
+    const char * negative[] = { "0", "false", "no" };
+
+    // For each boolean value, ensure that it returns as expected
+    for(off_t i = 0; i < elems(positive); ++i) {
+        argv[2] = positive[i];
+        p->parse_args(elems(argv), argv);
+        CHECK (value == true);
+    }
+
+    for(off_t i = 0; i < elems(negative); ++i) {
+        argv[2] = negative[i];
+        p->parse_args(elems(argv), argv);
+        CHECK (value == false);
+    }
+
+    // Check that invalid forms of boolean all throw exceptions
+    const char *  invalid[] = { "foo", "y", "null" };
+
+    for(off_t i = 0; i < elems(invalid); ++i) {
+        argv[2] = invalid[i];
+        CHECK_THROWS (
+            std::domain_error,
+            p->parse_args (elems(argv), argv)
+        );
+    }
+}
+
+
+template<typename T>
+void test_numeric_opt(void) {
+    unique_ptr<processor> p(new processor());
+    T value;
+    p->add_option(new valueoption<T>('t', "type",
+                "testing type option", &value));
+
+    T values[] = {
+        // TODO: Enable minimum value testing. Currently disabled as
+        // a negative numerical value looks just like a proceeding
+        // option.
+        //numeric_limits<T>::min(),
+
+        numeric_limits<T>::max(),
+        0
+    };
+
+    const char * argv_short[] = { "./foo", "-t", NULL };
+    const char *  argv_long[] = { "./foo", NULL };
+
+    for(off_t i = 0; i < elems(values); ++i) {
+        ostringstream out_short, out_long;
+        string        str_short, str_long;
+
+        out_short << values[i];
+        str_short = out_short.str();
+        argv_short[2] = str_short.c_str();
+
+        value = 2;
+        p->parse_args(elems(argv_short), argv_short);
+        CHECK (value == values[i]);
+
+        out_long << "--type=" << values[i];
+        str_long = out_long.str();
+        argv_long[1] = str_long.c_str();
+
+        value = 2;
+        p->parse_args(elems(argv_long), argv_long);
+        CHECK (value == values[i]);
+    }
+}
+
+
+void test_bytes_opt(void) {
+    unique_ptr<processor> p(new processor());
+
+    struct {
+        const char *  param;
+        bytesoption::bytestype     type;
+        bytesoption::bytesmodifier mod;
+        size_t		  size;
+    } commands[] = {
+        { "1",	bytesoption::BYTES_MEGA,
+            bytesoption::BYTES_BASE2,
+            1UL * 1024 * 1024 },
+
+        { "1k", bytesoption::BYTES_KILO,
+            bytesoption::BYTES_BASE2,
+            1UL * 1024 },
+
+        { "1M", bytesoption::BYTES_SINGLE,
+            bytesoption::BYTES_BASE2,
+            1UL * 1024 * 1024 },
+
+        { "1G", bytesoption::BYTES_MEGA,
+            bytesoption::BYTES_BASE2,
+            1UL * 1024 * 1024 * 1024 },
+
+        { "1M", bytesoption::BYTES_SINGLE,
+            bytesoption::BYTES_BASE10,
+            1UL * 1000 * 1000 },
+
+        { "1MB", bytesoption::BYTES_SINGLE,
+            bytesoption::BYTES_BASE10,
+            1UL * 1000 * 1000 },
+
+        { "1MiB", bytesoption::BYTES_SINGLE,
+            bytesoption::BYTES_BASE10,
+            1UL * 1024 * 1024 },
+
+    };
+
+    const char * argv[] = { 
+        "./foo",
+        "-b",
+        NULL
+    };
+
+    for(unsigned int i = 0; i < elems(commands); ++i) {
+        size_t size = 0;
+        option * opt = new bytesoption('b', "bytes",
+                "testing sizeof bytes",  &size, commands[i].type,
+                commands[i].mod);
+        p->add_option(opt);
+
+        argv[elems(argv) - 1] = commands[i].param;
+        p->parse_args(elems(argv), argv);
+
+        CHECK_EQ (commands[i].size, size);
+        delete p->remove_option(opt);
+    }
+}
+
+
+void test_insert_remove_opt(void) {
+    unique_ptr<processor> p(new processor());
+    nulloption opt('n', "null-option", "null testing action");
+
+    p->add_option(&opt);
+    CHECK_EQ (p->remove_option('n'), (option*)&opt);
+
+    p->add_option(&opt);
+    CHECK_EQ (p->remove_option("null-option"), (option*)&opt);
+
+    p->add_option(&opt);
+    CHECK_THROWS (std::logic_error, p->add_option(&opt));
+
+    p->remove_option(&opt);
+}
+
+
+void test_required (void) {
+    unique_ptr<processor> p(new processor());
+    p->add_option (new nulloption ('n',
+                "null",
+                "null testing",
+                true));
+    static const char *argv[] = {
+        "./cpptest",
+        "-n",
+        "value"
+    };
+
+    CHECK_NOTHROW (p->parse_args (elems(argv), argv));
+    CHECK_THROWS  (std::runtime_error, p->parse_args (1, argv));
+}
+
+
+int
+main (int argc, char **argv) {
+    test_null_opt ();
+    test_present_opt ();
+    test_bool_opt ();
+    test_numeric_opt< int16_t> ();
+    test_numeric_opt< int32_t> ();
+    test_numeric_opt< int64_t> ();
+    test_numeric_opt<uint16_t> ();
+    test_numeric_opt<uint32_t> ();
+    test_numeric_opt<uint64_t> ();
+    test_bytes_opt ();
+    test_insert_remove_opt ();
+    test_required ();
+}