[DEV] add v1.66.0

libs/program_options/test/Jamfile.v2

@@ -0,0 +1,42 @@
+import testing ;
+
+project
+    : requirements 
+    <library>../build//boost_program_options
+    <link>static
+    <variant>debug
+    
+#    <define>_GLIBCXX_CONCEPT_CHECKS
+#    <define>_GLIBCXX_DEBUG
+    ;
+    
+rule po-test ( source : input-file ? )
+{
+    return
+        [ run $(source) : : $(input-file) ]
+        [ run $(source) : : $(input-file) 
+          : <link>shared <define>BOOST_PROGRAM_OPTIONS_DYN_LINK=1
+          : $(source:B)_dll ] 
+    ;   
+}    
+
+test-suite program_options :
+
+    [ po-test options_description_test.cpp ] 
+    [ po-test parsers_test.cpp : config_test.cfg ]
+    [ po-test variable_map_test.cpp ]
+    [ po-test cmdline_test.cpp ]
+    [ po-test positional_options_test.cpp ]
+    [ po-test unicode_test.cpp ] 
+    [ po-test winmain.cpp ] 
+    [ po-test exception_test.cpp ]
+    [ po-test split_test.cpp ]
+    [ po-test unrecognized_test.cpp ]
+    [ po-test required_test.cpp : required_test.cfg ]
+    [ po-test exception_txt_test.cpp ]
+    [ po-test optional_test.cpp ]
+    [ run options_description_test.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : options_description_no_rtti_test ]
+    ;
+        
+exe test_convert : test_convert.cpp ;   
+

libs/program_options/test/cmdline_test.cpp

@@ -0,0 +1,652 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/program_options/cmdline.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/detail/cmdline.hpp>
+using namespace boost::program_options;
+using boost::program_options::detail::cmdline;
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cassert>
+using namespace std;
+
+#include "minitest.hpp"
+
+/* To facilitate testing, declare a number of error codes. Otherwise,
+   we'd have to specify the type of exception that should be thrown.
+*/
+
+const int s_success = 0;
+const int s_unknown_option = 1;
+const int s_ambiguous_option = 2;
+const int s_long_not_allowed = 3;
+const int s_long_adjacent_not_allowed = 4;
+const int s_short_adjacent_not_allowed = 5;
+const int s_empty_adjacent_parameter = 6;
+const int s_missing_parameter = 7;
+const int s_extra_parameter = 8;
+const int s_unrecognized_line = 9;
+
+int translate_syntax_error_kind(invalid_command_line_syntax::kind_t k)
+{
+    invalid_command_line_syntax::kind_t table[] = {
+        invalid_command_line_syntax::long_not_allowed,
+        invalid_command_line_syntax::long_adjacent_not_allowed,
+        invalid_command_line_syntax::short_adjacent_not_allowed,
+        invalid_command_line_syntax::empty_adjacent_parameter,
+        invalid_command_line_syntax::missing_parameter,
+        invalid_command_line_syntax::extra_parameter,
+        invalid_command_line_syntax::unrecognized_line 
+    };
+    invalid_command_line_syntax::kind_t *b, *e, *i;
+    b = table;
+    e = table + sizeof(table)/sizeof(table[0]);
+    i = std::find(b, e, k);
+    assert(i != e);
+    return std::distance(b, i) + 3;
+}
+
+struct test_case {
+    const char* input;
+    int expected_status;
+    const char* expected_result;
+};
+
+
+/* Parses the syntax description in 'syntax' and initialized
+   'cmd' accordingly' 
+   The "boost::program_options" in parameter type is needed because CW9 
+   has std::detail and it causes an ambiguity.
+*/
+void apply_syntax(options_description& desc, 
+                  const char* syntax)
+{
+   
+    string s;
+    stringstream ss;
+    ss << syntax;
+    while(ss >> s) {
+        value_semantic* v = 0;
+        
+        if (*(s.end()-1) == '=') {
+            v = value<string>();
+            s.resize(s.size()-1);
+        } else if (*(s.end()-1) == '?') {
+            v = value<string>()->implicit_value("default");
+            s.resize(s.size()-1);
+        } else if (*(s.end()-1) == '*') {
+            v = value<vector<string> >()->multitoken();
+            s.resize(s.size()-1);
+        } else if (*(s.end()-1) == '+') {
+            v = value<vector<string> >()->multitoken();
+            s.resize(s.size()-1);
+        }
+        if (v) {
+            desc.add_options()
+                (s.c_str(), v, "");
+        } else {
+            desc.add_options()
+                (s.c_str(), "");
+        }
+    }
+}
+
+void test_cmdline(const char* syntax, 
+                  command_line_style::style_t style,
+                  const test_case* cases)
+{
+    for (int i = 0; cases[i].input; ++i) {
+        // Parse input
+        vector<string> xinput;
+        {
+            string s;
+            stringstream ss;
+            ss << cases[i].input;
+            while (ss >> s) {
+                xinput.push_back(s);
+            }
+        }
+        options_description desc;
+        apply_syntax(desc, syntax);
+
+        cmdline cmd(xinput);
+        cmd.style(style);
+        cmd.set_options_description(desc);
+
+
+        string result;
+        int status = 0;
+
+        try {
+            vector<option> options = cmd.run();
+
+            for(unsigned j = 0; j < options.size(); ++j)
+            {
+                option opt = options[j];
+
+                if (opt.position_key != -1) {
+                    if (!result.empty())
+                        result += " ";
+                    result += opt.value[0];
+                } else {
+                    if (!result.empty())
+                        result += " ";
+                    result += opt.string_key + ":";
+                    for (size_t k = 0; k < opt.value.size(); ++k) {
+                        if (k != 0)
+                            result += "-";
+                        result += opt.value[k];
+                    }                    
+                }
+            }
+        }
+        catch(unknown_option&) {
+            status = s_unknown_option;
+        }
+        catch(ambiguous_option&) {
+            status = s_ambiguous_option;
+        }
+        catch(invalid_command_line_syntax& e) {
+            status = translate_syntax_error_kind(e.kind());
+        }
+        BOOST_CHECK_EQUAL(status, cases[i].expected_status);
+        BOOST_CHECK_EQUAL(result, cases[i].expected_result);
+    }
+}
+
+void test_long_options()
+{
+    using namespace command_line_style;
+    cmdline::style_t style = cmdline::style_t(
+        allow_long | long_allow_adjacent);
+
+    test_case test_cases1[] = {
+        // Test that long options are recognized and everything else
+        // is treated like arguments
+        {"--foo foo -123 /asd", s_success, "foo: foo -123 /asd"},
+
+        // Unknown option
+        {"--unk", s_unknown_option, ""},
+
+        // Test that abbreviated names do not work
+        {"--fo", s_unknown_option, ""},
+
+        // Test for disallowed parameter
+        {"--foo=13", s_extra_parameter, ""},
+
+        // Test option with required parameter
+        {"--bar=", s_empty_adjacent_parameter, ""},
+        {"--bar", s_missing_parameter, ""},
+
+        {"--bar=123", s_success, "bar:123"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo bar=", style, test_cases1);
+
+
+    style = cmdline::style_t(
+        allow_long | long_allow_next);
+
+    test_case test_cases2[] = {
+        {"--bar 10", s_success, "bar:10"},
+        {"--bar", s_missing_parameter,  ""},
+        // Since --bar accepts a parameter, --foo is
+        // considered a value, even though it looks like
+        // an option.
+        {"--bar --foo", s_success, "bar:--foo"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo bar=", style, test_cases2);
+    style = cmdline::style_t(
+        allow_long | long_allow_adjacent
+        | long_allow_next);
+
+    test_case test_cases3[] = {
+        {"--bar=10", s_success, "bar:10"},
+        {"--bar 11", s_success, "bar:11"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo bar=", style, test_cases3);
+
+    style = cmdline::style_t(
+        allow_long | long_allow_adjacent
+        | long_allow_next | case_insensitive);
+
+    // Test case insensitive style.
+    // Note that option names are normalized to lower case.
+    test_case test_cases4[] = {
+        {"--foo", s_success, "foo:"},
+        {"--Foo", s_success, "foo:"},
+        {"--bar=Ab", s_success, "bar:Ab"},
+        {"--Bar=ab", s_success, "bar:ab"},
+        {"--giz", s_success, "Giz:"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo bar= baz? Giz", style, test_cases4);
+}
+
+void test_short_options()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short | allow_dash_for_short 
+        | short_allow_adjacent);
+
+    test_case test_cases1[] = {
+        {"-d d /bar", s_success, "-d: d /bar"},
+        // This is treated as error when long options are disabled
+        {"--foo", s_success, "--foo"},
+        {"-d13", s_extra_parameter, ""},
+        {"-f14", s_success, "-f:14"},
+        {"-g -f1", s_success, "-g: -f:1"},
+        {"-f", s_missing_parameter, ""},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f= ,g", style, test_cases1);
+
+    style = cmdline::style_t(
+        allow_short | allow_dash_for_short
+        | short_allow_next);
+
+    test_case test_cases2[] = {
+        {"-f 13", s_success, "-f:13"},
+        {"-f -13", s_success, "-f:-13"},
+        {"-f", s_missing_parameter, ""},
+        {"-f /foo", s_success, "-f:/foo"},
+        {"-f -d", s_missing_parameter, ""},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f=", style, test_cases2);
+
+    style = cmdline::style_t(
+        allow_short | short_allow_next
+        | allow_dash_for_short | short_allow_adjacent);
+
+    test_case test_cases3[] = {
+        {"-f10", s_success, "-f:10"},
+        {"-f 10", s_success, "-f:10"},
+        {"-f -d", s_missing_parameter, ""},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f=", style, test_cases3);
+
+    style = cmdline::style_t(
+        allow_short | short_allow_next
+        | allow_dash_for_short
+        | short_allow_adjacent | allow_sticky);
+
+    test_case test_cases4[] = {
+        {"-de", s_success, "-d: -e:"},
+        {"-df10", s_success, "-d: -f:10"},
+        // FIXME: review
+        //{"-d12", s_extra_parameter, ""},
+        {"-f12", s_success, "-f:12"},
+        {"-fe", s_success, "-f:e"},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f= ,e", style, test_cases4);
+
+}
+
+
+void test_dos_options()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short
+        | allow_slash_for_short | short_allow_adjacent);
+
+    test_case test_cases1[] = {
+        {"/d d -bar", s_success, "-d: d -bar"},
+        {"--foo", s_success, "--foo"},
+        {"/d13", s_extra_parameter, ""},
+        {"/f14", s_success, "-f:14"},
+        {"/f", s_missing_parameter, ""},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f=", style, test_cases1);
+
+    style = cmdline::style_t(
+        allow_short 
+        | allow_slash_for_short | short_allow_next
+        | short_allow_adjacent | allow_sticky);
+
+    test_case test_cases2[] = {
+        {"/de", s_extra_parameter, ""},
+        {"/fe", s_success, "-f:e"},
+        {0, 0, 0}
+    };
+    test_cmdline(",d ,f= ,e", style, test_cases2);
+
+}
+
+
+void test_disguised_long()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short | short_allow_adjacent
+        | allow_dash_for_short
+        | short_allow_next | allow_long_disguise
+        | long_allow_adjacent);
+
+    test_case test_cases1[] = {
+        {"-foo -f", s_success, "foo: foo:"},
+        {"-goo=x -gy", s_success, "goo:x goo:y"},
+        {"-bee=x -by", s_success, "bee:x bee:y"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo,f goo,g= bee,b?", style, test_cases1);
+
+    style = cmdline::style_t(style | allow_slash_for_short);
+    test_case test_cases2[] = {
+        {"/foo -f", s_success, "foo: foo:"},
+        {"/goo=x", s_success, "goo:x"},
+        {0, 0, 0}
+    };
+    test_cmdline("foo,f goo,g= bee,b?", style, test_cases2);
+}
+
+void test_guessing()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short | short_allow_adjacent
+        | allow_dash_for_short        
+        | allow_long | long_allow_adjacent
+        | allow_guessing | allow_long_disguise);
+
+    test_case test_cases1[] = {
+        {"--opt1", s_success, "opt123:"},
+        {"--opt", s_ambiguous_option, ""},
+        {"--f=1", s_success, "foo:1"},
+        {"-far", s_success, "foo:ar"},
+        {0, 0, 0}
+    };
+    test_cmdline("opt123 opt56 foo,f=", style, test_cases1);
+
+    test_case test_cases2[] = { 
+        {"--fname file --fname2 file2", s_success, "fname: file fname2: file2"},
+        {"--fnam file --fnam file2", s_ambiguous_option, ""},
+        {"--fnam file --fname2 file2", s_ambiguous_option, ""},
+        {"--fname2 file2 --fnam file", s_ambiguous_option, ""},
+        {0, 0, 0} 
+    };
+    test_cmdline("fname fname2", style, test_cases2);
+}
+
+void test_arguments()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short | allow_long
+        | allow_dash_for_short
+        | short_allow_adjacent | long_allow_adjacent);
+
+    test_case test_cases1[] = {
+        {"-f file -gx file2", s_success, "-f: file -g:x file2"},
+        {"-f - -gx - -- -e", s_success, "-f: - -g:x - -e"},
+        {0, 0, 0}
+    };
+    test_cmdline(",f ,g= ,e", style, test_cases1);
+
+    // "--" should stop options regardless of whether long options are
+    // allowed or not.
+
+    style = cmdline::style_t(
+        allow_short | short_allow_adjacent
+        | allow_dash_for_short);
+
+    test_case test_cases2[] = {
+        {"-f - -gx - -- -e", s_success, "-f: - -g:x - -e"},
+        {0, 0, 0}
+    };
+    test_cmdline(",f ,g= ,e", style, test_cases2);
+}
+
+void test_prefix()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_short | allow_long
+        | allow_dash_for_short
+        | short_allow_adjacent | long_allow_adjacent
+        );
+
+    test_case test_cases1[] = {
+        {"--foo.bar=12", s_success, "foo.bar:12"},
+        {0, 0, 0}
+    };
+
+    test_cmdline("foo*=", style, test_cases1);
+}
+
+
+pair<string, string> at_option_parser(string const&s)
+{
+    if ('@' == s[0])
+        return std::make_pair(string("response-file"), s.substr(1));
+    else
+        return pair<string, string>();
+}
+
+pair<string, string> at_option_parser_broken(string const&s)
+{
+    if ('@' == s[0])
+        return std::make_pair(string("some garbage"), s.substr(1));
+    else
+        return pair<string, string>();
+}
+
+
+
+void test_additional_parser()
+{
+    options_description desc;
+    desc.add_options()
+        ("response-file", value<string>(), "response file")
+        ("foo", value<int>(), "foo")
+        ;
+
+    vector<string> input;
+    input.push_back("@config");
+    input.push_back("--foo=1");
+
+    cmdline cmd(input);
+    cmd.set_options_description(desc);
+    cmd.set_additional_parser(at_option_parser);
+
+    vector<option> result = cmd.run();
+
+    BOOST_REQUIRE(result.size() == 2);
+    BOOST_CHECK_EQUAL(result[0].string_key, "response-file");
+    BOOST_CHECK_EQUAL(result[0].value[0], "config");
+    BOOST_CHECK_EQUAL(result[1].string_key, "foo");
+    BOOST_CHECK_EQUAL(result[1].value[0], "1");    
+
+    // Test that invalid options returned by additional style
+    // parser are detected.
+    cmdline cmd2(input);
+    cmd2.set_options_description(desc);
+    cmd2.set_additional_parser(at_option_parser_broken);
+
+    BOOST_CHECK_THROW(cmd2.run(), unknown_option);
+
+}
+
+vector<option> at_option_parser2(vector<string>& args)
+{
+    vector<option> result;
+    if ('@' == args[0][0]) {
+        // Simulate reading the response file.
+        result.push_back(option("foo", vector<string>(1, "1")));
+        result.push_back(option("bar", vector<string>(1, "1")));
+        args.erase(args.begin());
+    }
+    return result;
+}
+
+
+void test_style_parser()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo", value<int>(), "foo")
+        ("bar", value<int>(), "bar")
+        ;
+
+    vector<string> input;
+    input.push_back("@config");
+
+    cmdline cmd(input);
+    cmd.set_options_description(desc);
+    cmd.extra_style_parser(at_option_parser2);
+
+    vector<option> result = cmd.run();
+
+    BOOST_REQUIRE(result.size() == 2);
+    BOOST_CHECK_EQUAL(result[0].string_key, "foo");
+    BOOST_CHECK_EQUAL(result[0].value[0], "1");    
+    BOOST_CHECK_EQUAL(result[1].string_key, "bar");
+    BOOST_CHECK_EQUAL(result[1].value[0], "1");    
+}
+
+void test_unregistered()
+{
+    // Check unregisted option when no options are registed at all.
+    options_description desc;
+
+    vector<string> input;
+    input.push_back("--foo=1");
+    input.push_back("--bar");
+    input.push_back("1");
+    input.push_back("-b");
+    input.push_back("-biz");
+
+    cmdline cmd(input);
+    cmd.set_options_description(desc);
+    cmd.allow_unregistered();
+    
+    vector<option> result = cmd.run();
+    BOOST_REQUIRE(result.size() == 5);
+    // --foo=1
+    BOOST_CHECK_EQUAL(result[0].string_key, "foo");
+    BOOST_CHECK_EQUAL(result[0].unregistered, true);
+    BOOST_CHECK_EQUAL(result[0].value[0], "1");
+    // --bar
+    BOOST_CHECK_EQUAL(result[1].string_key, "bar");
+    BOOST_CHECK_EQUAL(result[1].unregistered, true);
+    BOOST_CHECK(result[1].value.empty());
+    // '1' is considered a positional option, not a value to
+    // --bar
+    BOOST_CHECK(result[2].string_key.empty());
+    BOOST_CHECK(result[2].position_key == 0);
+    BOOST_CHECK_EQUAL(result[2].unregistered, false);
+    BOOST_CHECK_EQUAL(result[2].value[0], "1");
+    // -b
+    BOOST_CHECK_EQUAL(result[3].string_key, "-b");
+    BOOST_CHECK_EQUAL(result[3].unregistered, true);
+    BOOST_CHECK(result[3].value.empty());
+    // -biz
+    BOOST_CHECK_EQUAL(result[4].string_key, "-b");
+    BOOST_CHECK_EQUAL(result[4].unregistered, true);
+    BOOST_CHECK_EQUAL(result[4].value[0], "iz");
+
+    // Check sticky short options together with unregisted options.
+    
+    desc.add_options()
+        ("help,h", "")
+        ("magic,m", value<string>(), "")
+        ;
+
+    input.clear();
+    input.push_back("-hc");
+    input.push_back("-mc");
+
+
+    cmdline cmd2(input);
+    cmd2.set_options_description(desc);
+    cmd2.allow_unregistered();
+    
+    result = cmd2.run();
+
+    BOOST_REQUIRE(result.size() == 3);
+    BOOST_CHECK_EQUAL(result[0].string_key, "help");
+    BOOST_CHECK_EQUAL(result[0].unregistered, false);
+    BOOST_CHECK(result[0].value.empty());
+    BOOST_CHECK_EQUAL(result[1].string_key, "-c");
+    BOOST_CHECK_EQUAL(result[1].unregistered, true);
+    BOOST_CHECK(result[1].value.empty());
+    BOOST_CHECK_EQUAL(result[2].string_key, "magic");
+    BOOST_CHECK_EQUAL(result[2].unregistered, false);
+    BOOST_CHECK_EQUAL(result[2].value[0], "c");
+
+    // CONSIDER:
+    // There's a corner case:
+    //   -foo
+    // when 'allow_long_disguise' is set. Should this be considered
+    // disguised long option 'foo' or short option '-f' with value 'oo'?
+    // It's not clear yet, so I'm leaving the decision till later.
+}
+
+void test_implicit_value()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_long | long_allow_adjacent
+        );
+
+    test_case test_cases1[] = {
+        // 'bar' does not even look like option, so is consumed
+        {"--foo bar", s_success, "foo:bar"},
+        // '--bar' looks like option, and such option exists, so we don't consume this token
+        {"--foo --bar", s_success, "foo: bar:"},
+        // '--biz' looks like option, but does not match any existing one.
+        // Presently this results in parse error, since
+        // (1) in cmdline.cpp:finish_option, we only consume following tokens if they are
+        // requires
+        // (2) in cmdline.cpp:run, we let options consume following positional options
+        // For --biz, an exception is thrown between 1 and 2.
+        // We might want to fix that in future.
+        {"--foo --biz", s_unknown_option, ""},
+        {0, 0, 0}
+    };
+
+    test_cmdline("foo? bar?", style, test_cases1);
+}
+
+int main(int /*ac*/, char** /*av*/)
+{
+    test_long_options();
+    test_short_options();
+    test_dos_options();
+    test_disguised_long();
+    test_guessing();
+    test_arguments();
+    test_prefix();
+    test_additional_parser();
+    test_style_parser();
+    test_unregistered();
+    test_implicit_value();
+
+    return 0;
+}

libs/program_options/test/config_test.cfg

@@ -0,0 +1,9 @@
+gv1 = 0#asd
+empty_value = 
+plug3 = 7
+b = true
+
+[m1]
+v1 = 1
+
+v2 = 2

libs/program_options/test/exception_test.cpp

@@ -0,0 +1,164 @@
+// Copyright Sascha Ochsenknecht 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/cmdline.hpp>
+using namespace boost::program_options;
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cassert>
+using namespace std;
+
+#include "minitest.hpp"
+
+
+void test_ambiguous() 
+{
+    options_description desc; 
+    desc.add_options()
+        ("cfgfile,c", value<string>()->multitoken(), "the config file") 
+        ("output,c", value<string>(), "the output file") 
+        ("output,o", value<string>(), "the output file")
+    ;
+
+    const char* cmdline[] = {"program", "-c", "file", "-o", "anotherfile"};
+
+    variables_map vm;
+    try {
+       store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
+                                    const_cast<char**>(cmdline), desc), vm);
+    }
+    catch (ambiguous_option& e)
+    {
+        BOOST_CHECK_EQUAL(e.alternatives().size(), 2);
+        BOOST_CHECK_EQUAL(e.get_option_name(), "-c");      
+        BOOST_CHECK_EQUAL(e.alternatives()[0], "cfgfile");
+        BOOST_CHECK_EQUAL(e.alternatives()[1], "output");
+    }
+}
+
+
+
+void test_unknown_option() 
+{
+   options_description desc;
+   desc.add_options()
+        ("cfgfile,c", value<string>(), "the configfile")
+      ;
+
+   const char* cmdline[] = {"program", "-c", "file", "-f", "anotherfile"};
+   
+   variables_map vm;
+   try {
+      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
+                                    const_cast<char**>(cmdline), desc), vm);
+   }
+   catch (unknown_option& e)
+   {
+      BOOST_CHECK_EQUAL(e.get_option_name(), "-f");      
+      BOOST_CHECK_EQUAL(string(e.what()), "unrecognised option '-f'");
+   }
+}
+
+
+
+void test_multiple_values() 
+{
+   options_description desc;
+   desc.add_options()
+        ("cfgfile,c", value<string>()->multitoken(), "the config file")
+        ("output,o", value<string>(), "the output file")
+      ;
+
+   const char* cmdline[] = { "program", "-o", "fritz", "hugo", "--cfgfile", "file", "c", "-o", "text.out" };
+   
+   variables_map vm;
+   try {
+      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
+                                    const_cast<char**>(cmdline), desc), vm);
+      notify(vm);
+   }
+   catch (validation_error& e)
+   {
+      // TODO: this is currently validation_error, shouldn't it be multiple_values ???
+      // 
+      //   multiple_values is thrown only at one place untyped_value::xparse(),
+      //    but I think this can never be reached
+      //   because: untyped_value always has one value and this is filtered before reach specific
+      //   validation and parsing
+      //
+      BOOST_CHECK_EQUAL(e.get_option_name(), "--cfgfile");      
+      BOOST_CHECK_EQUAL(string(e.what()), "option '--cfgfile' only takes a single argument");
+   }
+}
+
+
+
+void test_multiple_occurrences()
+{
+   options_description desc;
+   desc.add_options()
+        ("cfgfile,c", value<string>(), "the configfile")
+      ;
+
+   const char* cmdline[] = {"program", "--cfgfile", "file", "-c", "anotherfile"};
+   
+   variables_map vm;
+   try {
+      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
+                                    const_cast<char**>(cmdline), desc), vm);
+      notify(vm);
+   }
+   catch (multiple_occurrences& e)
+   {
+      BOOST_CHECK_EQUAL(e.get_option_name(), "--cfgfile");      
+      BOOST_CHECK_EQUAL(string(e.what()), "option '--cfgfile' cannot be specified more than once");
+   }
+}
+
+
+
+void test_missing_value()
+{
+    options_description desc;
+    desc.add_options()
+        ("cfgfile,c", value<string>()->multitoken(), "the config file") 
+        ("output,o", value<string>(), "the output file")
+    ;
+    // missing value for option '-c'
+    const char* cmdline[] = { "program", "-c", "-c", "output.txt"};
+    
+    variables_map vm;
+    
+    try {
+      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
+                                       const_cast<char**>(cmdline), desc), vm);
+      notify(vm);
+   } 
+   catch (invalid_command_line_syntax& e)
+   {
+      BOOST_CHECK_EQUAL(e.kind(), invalid_syntax::missing_parameter);
+      BOOST_CHECK_EQUAL(e.tokens(), "--cfgfile");
+   }
+}
+
+
+
+int main(int /*ac*/, char** /*av*/)
+{
+   test_ambiguous();
+   test_unknown_option();
+   test_multiple_values();
+   test_multiple_occurrences();
+   test_missing_value();
+
+   return 0;
+}
+

libs/program_options/test/exception_txt_test.cpp

@@ -0,0 +1,693 @@
+// Copyright Leo Goodstadt 2012
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/cmdline.hpp>
+using namespace boost::program_options;
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cassert>
+using namespace std;
+
+#include "minitest.hpp"
+
+
+
+// 
+//  like BOOST_CHECK_EQUAL but with more descriptive error message
+//
+#define CHECK_EQUAL(description, a, b) if (a != b) {std::cerr << "\n\nError:\n<<" << \
+        description << ">>\n  Expected text=\"" << b << "\"\n  Actual text  =\"" << a << "\"\n\n"; assert(a == b);}
+
+
+// Uncomment for Debugging, removes asserts so we can see more failures!
+//#define BOOST_ERROR(description) std::cerr << description; std::cerr << "\n"; 
+
+
+//8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
+// 
+//  Uncomment to print out the complete set of diagnostic messages for the different test cases
+/*
+#define CHECK_EQUAL(description, a, b) if (a != b) {std::cerr << "\n\nError:  " << \
+    description << "\n  Expecting\n" << b << "\n  Found\n" << a << "\n\n"; } \
+    else {std::cout << description<< "\t" << b << "\n";}
+*/ 
+
+//8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888
+
+
+// 
+//  test exception for each specified command line style, e.g. short dash or config file
+//
+template<typename EXCEPTION>
+void test_each_exception_message(const string& test_description, const vector<const char*>& argv, options_description& desc, int style, string exception_msg, istream& is = cin)
+{
+    if (exception_msg.length() == 0)
+        return;
+    variables_map vm;
+    unsigned argc = argv.size();
+
+
+    try {
+        if (style == -1)
+            store(parse_config_file(is, desc), vm);
+        else
+            store(parse_command_line(argv.size(), &argv[0], desc, style), vm);
+        notify(vm);    
+    } 
+    catch (EXCEPTION& e)
+    {
+       //cerr << "Correct:\n\t" << e.what() << "\n";
+       CHECK_EQUAL(test_description, e.what(), exception_msg);
+       return;
+    }
+    catch (std::exception& e)
+    {
+        // concatenate argv without boost::algorithm::join
+        string argv_txt;
+        for (unsigned ii = 0; ii < argc - 1; ++ii)
+            argv_txt += argv[ii] + string(" ");
+        if (argc)
+            argv_txt += argv[argc - 1];
+
+       BOOST_ERROR("\n<<" + test_description + 
+                    string(">>\n  Unexpected exception type!\n  Actual text  =\"") + e.what() + 
+                    "\"\n  argv         =\"" + argv_txt +
+                    "\"\n  Expected text=\"" + exception_msg + "\"\n");
+       return;
+    }
+    BOOST_ERROR(test_description + ": No exception thrown. ");
+}
+
+
+
+
+// 
+//  test exception messages for all command line styles (unix/long/short/slash/config file)
+//
+//      try each command line style in turn
+const int unix_style = command_line_style::unix_style;
+const int short_dash = command_line_style::allow_dash_for_short | command_line_style::allow_short | command_line_style::short_allow_adjacent | command_line_style::allow_sticky;
+const int short_slash = command_line_style::allow_slash_for_short | command_line_style::allow_short | command_line_style::short_allow_adjacent;
+const int long_dash = command_line_style::allow_long | command_line_style::long_allow_adjacent | command_line_style::allow_guessing;
+
+
+
+template<typename EXCEPTION>
+void test_exception_message(const vector<vector<const char*> >& argv,
+                            options_description& desc,
+                            const string& error_description, 
+                            const char* expected_message_template[5])
+{
+    string expected_message;
+
+    // unix
+    expected_message = expected_message_template[0];
+    test_each_exception_message<EXCEPTION>(error_description + " -- unix", 
+                                  argv[0], desc, unix_style, expected_message);
+
+    // long dash only
+    expected_message = expected_message_template[1];
+    test_each_exception_message<EXCEPTION>(error_description + " -- long_dash", 
+                                  argv[1], desc, long_dash, expected_message);
+
+
+    // short dash only
+    expected_message = expected_message_template[2];
+    test_each_exception_message<EXCEPTION>(error_description + " -- short_dash", 
+                                  argv[2], desc, short_dash, expected_message);
+
+    // short slash only
+    expected_message = expected_message_template[3];
+    test_each_exception_message<EXCEPTION>(error_description + " -- short_slash", 
+                                  argv[3], desc, short_slash, expected_message);
+
+    // config file only
+    expected_message = expected_message_template[4];
+    if (expected_message.length())
+    {
+        istringstream istrm(argv[4][0]);
+        test_each_exception_message<EXCEPTION>(error_description + " -- config_file", 
+                                          argv[4], desc, -1, expected_message, istrm);
+    }
+
+}
+
+#define VEC_STR_PUSH_BACK(vec, c_array)  \
+    vec.push_back(vector<const char*>(c_array, c_array + sizeof(c_array) / sizeof(char*)));
+
+//________________________________________________________________________________________
+// 
+//  invalid_option_value
+//
+//________________________________________________________________________________________
+void test_invalid_option_value_exception_msg()
+{
+    options_description desc;
+    desc.add_options()
+        ("int-option,d", value< int >(),        "An option taking an integer")
+    ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = { "program", "-d", "A_STRING"}   ;  VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = { "program", "--int", "A_STRING"};  VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = { "program", "-d", "A_STRING"}   ;  VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = { "program", "/d", "A_STRING"}   ;  VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "int-option=A_STRING"}         ;  VEC_STR_PUSH_BACK(argv, argv4); 
+
+    const char* expected_msg[5] = {
+                                "the argument ('A_STRING') for option '--int-option' is invalid", 
+                                "the argument ('A_STRING') for option '--int-option' is invalid", 
+                                "the argument ('A_STRING') for option '-d' is invalid", 
+                                "the argument ('A_STRING') for option '/d' is invalid", 
+                                "the argument ('A_STRING') for option 'int-option' is invalid",
+    };
+
+
+    test_exception_message<invalid_option_value>(argv, desc, "invalid_option_value",
+                                                 expected_msg);
+
+
+}
+
+//________________________________________________________________________________________
+// 
+//  missing_value
+//
+//________________________________________________________________________________________
+void test_missing_value_exception_msg()
+{
+    options_description desc;
+    desc.add_options()
+        ("cfgfile,e", value<string>(), "the config file") 
+        ("output,o", value<string>(), "the output file")
+    ;
+    vector<vector<const char*> > argv;
+    const char* argv0[] = { "program", "-e", "-e", "output.txt"} ; VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = { "program", "--cfgfile"}              ; VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = { "program", "-e", "-e", "output.txt"} ; VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = { "program", "/e", "/e", "output.txt"} ; VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { ""}    ;      VEC_STR_PUSH_BACK(argv, argv4); 
+
+    const char* expected_msg[5] = {
+                                "the required argument for option '--cfgfile' is missing",
+                                "the required argument for option '--cfgfile' is missing",
+                                "the required argument for option '-e' is missing",
+                                "", // Ignore probable bug in cmdline::finish_option
+                                    //"the required argument for option '/e' is missing",
+                                "",
+    };
+    test_exception_message<invalid_command_line_syntax>(argv, desc, 
+                                                        "invalid_syntax::missing_parameter", 
+                                                        expected_msg);
+}
+
+//________________________________________________________________________________________
+// 
+//  ambiguous_option
+//
+//________________________________________________________________________________________
+void test_ambiguous_option_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+        ("cfgfile1,c", value<string>(), "the config file") 
+        ("cfgfile2,o",  value<string>(), "the config file") 
+        ("good,g",                          "good option") 
+        ("output,c",   value<string>(), "the output file") 
+        ("output",     value<string>(), "the output file") 
+    ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = {"program", "-ggc", "file", "-o", "anotherfile"}             ; VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = {"program", "--cfgfile", "file", "--cfgfile", "anotherfile"} ; VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = {"program", "-ggc", "file", "-o", "anotherfile"}             ; VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = {"program", "/c", "file", "/o", "anotherfile"}               ; VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "output=output.txt\n"}                                     ; VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {
+                                "option '-c' is ambiguous and matches '--cfgfile1', and '--output'",
+                                "option '--cfgfile' is ambiguous and matches '--cfgfile1', and '--cfgfile2'",
+                                "option '-c' is ambiguous",
+                                "option '/c' is ambiguous",
+                                "option 'output' is ambiguous and matches different versions of 'output'",
+    };
+    test_exception_message<ambiguous_option>(argv, desc, "ambiguous_option",
+                                             expected_msg);
+}
+
+//________________________________________________________________________________________
+// 
+//  multiple_occurrences
+//
+//________________________________________________________________________________________
+void test_multiple_occurrences_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+                ("cfgfile,c", value<string>(), "the configfile")
+    ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = {"program", "-c", "file", "-c", "anotherfile"}           ; VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = {"program", "--cfgfi", "file", "--cfgfi", "anotherfile"} ; VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = {"program", "-c", "file", "-c", "anotherfile"}           ; VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = {"program", "/c", "file", "/c", "anotherfile"}           ; VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "cfgfile=output.txt\ncfgfile=output.txt\n"}            ; VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {
+                                "option '--cfgfile' cannot be specified more than once",
+                                "option '--cfgfile' cannot be specified more than once",
+                                "option '-c' cannot be specified more than once",
+                                "option '/c' cannot be specified more than once",
+                                "option 'cfgfile' cannot be specified more than once",
+    };
+    test_exception_message<multiple_occurrences>(argv, desc, "multiple_occurrences",
+                                                expected_msg);
+}
+
+//________________________________________________________________________________________
+// 
+//  unknown_option
+//
+//________________________________________________________________________________________
+void test_unknown_option_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+        ("good,g",                          "good option") 
+    ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = {"program", "-ggc", "file"}      ; VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = {"program", "--cfgfile", "file"} ; VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = {"program", "-ggc", "file"}      ; VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = {"program", "/c", "file"}        ; VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "cfgfile=output.txt\n"}        ; VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {
+                                "unrecognised option '-ggc'",
+                                "unrecognised option '--cfgfile'",
+                                "unrecognised option '-ggc'",
+                                "unrecognised option '/c'",
+                                "unrecognised option 'cfgfile'",
+    };
+    test_exception_message<unknown_option>(argv, desc, "unknown_option", expected_msg);
+}
+
+//________________________________________________________________________________________
+// 
+//  validation_error::invalid_bool_value
+//
+//________________________________________________________________________________________
+void test_invalid_bool_value_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+        ("bool_option,b",       value< bool>(), "bool_option")
+        ;
+
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = {"program", "-b", "file"}           ; VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = {"program", "--bool_optio", "file"} ; VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = {"program", "-b", "file"}           ; VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = {"program", "/b", "file"}           ; VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "bool_option=output.txt\n"}       ; VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {                               
+                                "the argument ('file') for option '--bool_option' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'",
+                                "the argument ('file') for option '--bool_option' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'",
+                                "the argument ('file') for option '-b' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'",
+                                "the argument ('file') for option '/b' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'",
+                                "the argument ('output.txt') for option 'bool_option' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'",
+    };
+    test_exception_message<validation_error>(argv, 
+                                desc,
+                                "validation_error::invalid_bool_value",
+                                expected_msg);
+}
+
+
+
+
+//________________________________________________________________________________________
+// 
+//  validation_error::multiple_values_not_allowed
+//
+//________________________________________________________________________________________
+//
+//  Strange exception: sole purpose seems to be catching multitoken() associated with a scalar
+//  validation_error::multiple_values_not_allowed seems thus to be a programmer error
+//  
+//
+void test_multiple_values_not_allowed_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+         ("cfgfile,c", value<string>()->multitoken(), "the config file")
+         ("good,g",                                     "good option")
+         ("output,o", value<string>(),                  "the output file")
+       ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = { "program", "-c", "file", "c", "-o", "fritz", "hugo" }              ;      VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = { "program", "--cfgfil", "file", "c", "--outpu", "fritz", "hugo" }   ;      VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = { "program", "-c", "file", "c", "-o", "fritz", "hugo"}               ;      VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = { "program", "/c", "file", "c", "/o", "fritz", "hugo"}               ;      VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "" }                                                               ;      VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {                               
+                                "option '--cfgfile' only takes a single argument",
+                                "option '--cfgfile' only takes a single argument",
+                                "option '-c' only takes a single argument",
+                                "option '/c' only takes a single argument",
+                                "",
+    };
+    test_exception_message<validation_error>(argv, 
+                                desc,
+                                "validation_error::multiple_values_not_allowed",
+                                expected_msg);
+}
+
+//________________________________________________________________________________________
+// 
+//  validation_error::at_least_one_value_required
+//
+//________________________________________________________________________________________
+//
+//  Strange exception: sole purpose seems to be catching zero_tokens() associated with a scalar
+//  validation_error::multiple_values_not_allowed seems thus to be a programmer error
+//  
+//
+void test_at_least_one_value_required_exception_msg()
+{
+
+
+    options_description desc; 
+    desc.add_options()
+         ("cfgfile,c", value<int>()->zero_tokens(), "the config file")
+         ("other,o", value<string>(), "other")
+       ;
+
+    vector<vector<const char*> > argv;
+    const char* argv0[] = { "program", "-c"                       }  ;      VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = { "program", "--cfg", "--o", "name"     }  ;      VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = { "program", "-c"   , "-o"   , "name"   }  ;      VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = { "program", "/c"                       }  ;      VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { ""                                    }  ;      VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {                               
+                                "option '--cfgfile' requires at least one argument",
+                                "option '--cfgfile' requires at least one argument",
+                                "option '-c' requires at least one argument",
+                                "option '/c' requires at least one argument",
+                                "",
+    };
+    test_exception_message<validation_error>(argv, 
+                                desc,
+                                "validation_error::at_least_one_value_required",
+                                expected_msg);
+}
+
+
+//________________________________________________________________________________________
+// 
+//  required_option
+//
+//________________________________________________________________________________________
+void test_required_option_exception_msg()
+{
+    options_description desc; 
+    desc.add_options()
+         ("cfgfile,c", value<string>()->required(), "the config file")
+         ("good,g",                                 "good option")
+         ("output,o", value<string>()->required(),  "the output file")
+       ;
+
+    vector<vector<const char*> > argv;            
+    const char* argv0[] = { "program", "-g" }    ;      VEC_STR_PUSH_BACK(argv, argv0);
+    const char* argv1[] = { "program", "--g" }   ;      VEC_STR_PUSH_BACK(argv, argv1); 
+    const char* argv2[] = { "program", "-g"}     ;      VEC_STR_PUSH_BACK(argv, argv2);
+    const char* argv3[] = { "program", "/g"}     ;      VEC_STR_PUSH_BACK(argv, argv3); 
+    const char* argv4[] = { "" }                 ;      VEC_STR_PUSH_BACK(argv, argv4); 
+    const char* expected_msg[5] = {                               
+                                "the option '--cfgfile' is required but missing",
+                                "the option '--cfgfile' is required but missing",
+                                "the option '-c' is required but missing",
+                                "the option '/c' is required but missing",
+                                "the option 'cfgfile' is required but missing",
+    };
+    test_exception_message<required_option>(argv, 
+                                desc,
+                                "required_option",
+                                expected_msg);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** 
+ * Check if this is the expected exception with the right message is being thrown inside 
+ * func 
+*/
+template <typename EXCEPTION, typename FUNC>
+void test_exception(const string& test_name, const string& exception_txt, FUNC func)
+{
+
+    try {
+        options_description desc; 
+        variables_map vm;
+        func(desc, vm);
+    } 
+    catch (EXCEPTION& e)
+    {
+       CHECK_EQUAL(test_name, e.what(), exception_txt);
+       return;
+    }
+    catch (std::exception& e)
+    {
+       BOOST_ERROR(string(test_name + ":\nUnexpected exception. ") + e.what() + 
+                   "\nExpected text:\n" + exception_txt + "\n\n");
+       return;
+    }
+    BOOST_ERROR(test_name + ": No exception thrown. ");
+}
+
+
+
+//________________________________________________________________________________________
+// 
+//  check_reading_file
+//
+//________________________________________________________________________________________
+void check_reading_file(options_description& desc, variables_map& vm)
+{
+    desc.add_options()
+         ("output,o", value<string>(), "the output file");
+    
+    const char* file_name = "no_such_file";
+    store(parse_config_file<char>(file_name, desc, true), vm);
+
+}
+
+
+//________________________________________________________________________________________
+// 
+//  config_file_wildcard
+//
+//________________________________________________________________________________________
+void config_file_wildcard(options_description& desc, variables_map& vm)
+{
+    desc.add_options()
+         ("outpu*", value<string>(), "the output file1")
+         ("outp*",    value<string>(), "the output file2")
+       ;
+    istringstream is("output1=whichone\noutput2=whichone\n");
+    store(parse_config_file(is, desc), vm);
+}
+
+//________________________________________________________________________________________
+// 
+//  invalid_syntax::unrecognized_line
+//
+//________________________________________________________________________________________
+void unrecognized_line(options_description& desc, variables_map& vm)
+{
+    istringstream is("funny wierd line\n");
+    store(parse_config_file(is, desc), vm);
+}
+
+//________________________________________________________________________________________
+// 
+//  abbreviated_options_in_config_file
+//
+//________________________________________________________________________________________
+void abbreviated_options_in_config_file(options_description& desc, variables_map& vm)
+{
+    desc.add_options()(",o", value<string>(), "the output file");
+    istringstream is("o=output.txt\n");
+    store(parse_config_file(is, desc), vm);
+}
+
+
+//________________________________________________________________________________________
+// 
+//  too_many_positional_options
+//
+//________________________________________________________________________________________
+void too_many_positional_options(options_description& desc, variables_map& vm)
+{
+    const char* argv[] = {"program", "1", "2", "3"};
+    positional_options_description positional_args;
+    positional_args.add("two_positional_arguments", 2);
+    store(command_line_parser(4, argv).options(desc).positional(positional_args).run(), vm);
+}
+
+
+//________________________________________________________________________________________
+// 
+//  invalid_command_line_style
+//
+//________________________________________________________________________________________
+
+void test_invalid_command_line_style_exception_msg()
+{
+    string test_name = "invalid_command_line_style";
+    using namespace command_line_style;
+    options_description desc; 
+    desc.add_options()("output,o", value<string>(), "the output file");
+
+    vector<int> invalid_styles;
+    invalid_styles.push_back(allow_short | short_allow_adjacent);
+    invalid_styles.push_back(allow_short | allow_dash_for_short);
+    invalid_styles.push_back(allow_long);
+    vector<string> invalid_diagnostics;
+    invalid_diagnostics.push_back("boost::program_options misconfiguration: choose one "
+                                  "or other of 'command_line_style::allow_slash_for_short' "
+                                  "(slashes) or 'command_line_style::allow_dash_for_short' "
+                                  "(dashes) for short options.");
+    invalid_diagnostics.push_back("boost::program_options misconfiguration: choose one "
+                                  "or other of 'command_line_style::short_allow_next' "
+                                  "(whitespace separated arguments) or "
+                                  "'command_line_style::short_allow_adjacent' ('=' "
+                                  "separated arguments) for short options.");
+    invalid_diagnostics.push_back("boost::program_options misconfiguration: choose one "
+                                  "or other of 'command_line_style::long_allow_next' "
+                                  "(whitespace separated arguments) or "
+                                  "'command_line_style::long_allow_adjacent' ('=' "
+                                  "separated arguments) for long options.");
+
+
+    const char* argv[] = {"program"};
+    variables_map vm;
+    for (unsigned ii = 0; ii < 3; ++ii)
+    {
+        bool exception_thrown = false;
+        try
+        {
+            store(parse_command_line(1, argv, desc, invalid_styles[ii]), vm);
+        }
+        catch (invalid_command_line_style& e)
+        {
+           string error_msg("arguments are not allowed for unabbreviated option names");
+           CHECK_EQUAL(test_name, e.what(), invalid_diagnostics[ii]);
+           exception_thrown = true;
+        }
+        catch (std::exception& e)
+        {
+           BOOST_ERROR(string(test_name + ":\nUnexpected exception. ") + e.what() + 
+                            "\nExpected text:\n" + invalid_diagnostics[ii] + "\n");
+           exception_thrown = true;
+        }
+        if (!exception_thrown)
+        {
+            BOOST_ERROR(test_name << ": No exception thrown. ");
+        }
+    }
+}
+
+void test_empty_value_inner(options_description &opts, variables_map& vm) {
+    positional_options_description popts;
+    opts.add_options()("foo", value<uint32_t>()->value_name("<time>")->required());
+    popts.add("foo", 1);
+    vector<string> tokens{""};
+    parsed_options parsed = command_line_parser(tokens)
+        .style(command_line_style::default_style & ~command_line_style::allow_guessing)
+        .options(opts)
+        .positional(popts)
+        .run();
+    store(parsed, vm);
+}
+
+void test_empty_value() {
+    // Test that passing empty token for an option that requires integer does not result
+    // in out-of-range error in error reporting code.
+    test_exception<invalid_option_value>(
+        "test_empty_value",
+        "the argument for option '--foo' is invalid",
+        test_empty_value_inner);
+}
+
+int main(int /*ac*/, char** /*av*/)
+{
+   test_ambiguous_option_exception_msg();
+   test_unknown_option_exception_msg();
+   test_multiple_occurrences_exception_msg();
+   test_missing_value_exception_msg();
+   test_invalid_option_value_exception_msg();
+   test_invalid_bool_value_exception_msg();
+   test_multiple_values_not_allowed_exception_msg();
+   test_required_option_exception_msg();
+   test_at_least_one_value_required_exception_msg();
+   test_empty_value();
+
+   string test_name;
+   string expected_message;
+
+
+   // check_reading_file
+   test_name        = "check_reading_file";
+   expected_message = "can not read options configuration file 'no_such_file'";
+   test_exception<reading_file>(test_name, expected_message, check_reading_file);
+
+   // config_file_wildcard
+   test_name        = "config_file_wildcard";
+   expected_message = "options 'outpu*' and 'outp*' will both match the same arguments from the configuration file";
+   test_exception<error>(test_name, expected_message, config_file_wildcard);
+
+   // unrecognized_line
+   test_name        = "unrecognized_line";
+   expected_message = "the options configuration file contains an invalid line 'funny wierd line'";
+   test_exception<invalid_syntax>(test_name, expected_message, unrecognized_line);
+
+
+   // abbreviated_options_in_config_file
+   test_name        = "abbreviated_options_in_config_file";
+   expected_message = "abbreviated option names are not permitted in options configuration files";
+   test_exception<error>(test_name, expected_message, abbreviated_options_in_config_file);
+
+   test_name        = "too_many_positional_options";
+   expected_message = "too many positional options have been specified on the command line";
+   test_exception<too_many_positional_options_error>(
+                          test_name, expected_message, too_many_positional_options);
+
+   test_invalid_command_line_style_exception_msg();
+
+
+   return 0;
+}
+

libs/program_options/test/minitest.hpp

@@ -0,0 +1,25 @@
+#ifndef BOOST_PROGRAM_OPTIONS_MINITEST
+#define BOOST_PROGRAM_OPTIONS_MINITEST
+
+#include <assert.h>
+#include <iostream>
+#include <stdlib.h>
+
+#define BOOST_REQUIRE(b) assert(b)
+#define BOOST_CHECK(b) assert(b)
+#define BOOST_CHECK_EQUAL(a, b) assert(a == b)
+#define BOOST_ERROR(description) std::cerr << description; std::cerr << "\n"; abort();
+#define BOOST_CHECK_THROW(expression, exception) \
+    try \
+    { \
+        expression; \
+        BOOST_ERROR("expected exception not thrown");\
+        throw 10; \
+    } \
+    catch(exception &) \
+    { \
+    }
+
+
+
+#endif

libs/program_options/test/optional_test.cpp

@@ -0,0 +1,53 @@
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/program_options.hpp>
+namespace po = boost::program_options;
+
+#include <boost/optional.hpp>
+
+#include <string>
+
+#include "minitest.hpp"
+
+std::vector<std::string> sv(const char* array[], unsigned size)
+{
+    std::vector<std::string> r;
+    for (unsigned i = 0; i < size; ++i)
+        r.push_back(array[i]);
+    return r;
+}
+
+void test_optional()
+{
+    boost::optional<int> foo, bar, baz;
+
+    po::options_description desc;
+    desc.add_options()
+        ("foo,f", po::value(&foo), "")
+        ("bar,b", po::value(&bar), "")
+        ("baz,z", po::value(&baz), "")
+        ;
+
+    const char* cmdline1_[] = { "--foo=12", "--bar", "1"};
+    std::vector<std::string> cmdline1 = sv(cmdline1_,
+                                           sizeof(cmdline1_)/sizeof(const char*));
+    po::variables_map vm;
+    po::store(po::command_line_parser(cmdline1).options(desc).run(), vm);
+    po::notify(vm);
+
+    BOOST_REQUIRE(!!foo);
+    BOOST_CHECK(*foo == 12);
+
+    BOOST_REQUIRE(!!bar);
+    BOOST_CHECK(*bar == 1);
+
+    BOOST_CHECK(!baz);
+}
+
+int main(int, char*[])
+{
+    test_optional();
+    return 0;
+}

libs/program_options/test/options_description_test.cpp

@@ -0,0 +1,261 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/options_description.hpp>
+using namespace boost::program_options;
+
+#include <boost/function.hpp>
+using namespace boost;
+
+#include <utility>
+#include <string>
+#include <sstream>
+using namespace std;
+
+#include "minitest.hpp"
+
+void test_type()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo", value<int>(), "")
+        ("bar", value<string>(), "")
+        ;
+    
+#ifndef BOOST_NO_RTTI
+    const typed_value_base* b = dynamic_cast<const typed_value_base*>
+        (desc.find("foo", false).semantic().get());
+    BOOST_CHECK(b);
+    BOOST_CHECK(b->value_type() == typeid(int));
+
+    const typed_value_base* b2 = dynamic_cast<const typed_value_base*>
+        (desc.find("bar", false).semantic().get());
+    BOOST_CHECK(b2);
+    BOOST_CHECK(b2->value_type() == typeid(string));
+#endif
+}
+
+void test_approximation()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo", new untyped_value())
+        ("fee", new untyped_value())
+        ("baz", new untyped_value())
+        ("all-chroots", new untyped_value())
+        ("all-sessions", new untyped_value())
+        ("all", new untyped_value())
+        ;
+
+    BOOST_CHECK_EQUAL(desc.find("fo", true).long_name(), "foo");
+
+    BOOST_CHECK_EQUAL(desc.find("all", true).long_name(), "all");
+    BOOST_CHECK_EQUAL(desc.find("all-ch", true).long_name(), "all-chroots");
+
+    options_description desc2;
+    desc2.add_options()
+        ("help", "display this message")
+        ("config", value<string>(), "config file name")
+        ("config-value", value<string>(), "single config value")
+        ;
+
+    BOOST_CHECK_EQUAL(desc2.find("config", true).long_name(), "config");
+    BOOST_CHECK_EQUAL(desc2.find("config-value", true).long_name(), 
+                      "config-value");
+
+
+//    BOOST_CHECK(desc.count_approx("foo") == 1);
+//    set<string> a = desc.approximations("f");
+//    BOOST_CHECK(a.size() == 2);
+//    BOOST_CHECK(*a.begin() == "fee");
+//    BOOST_CHECK(*(++a.begin()) == "foo");
+}
+
+void test_formatting()
+{
+    // Long option descriptions used to crash on MSVC-8.0.
+    options_description desc;
+    desc.add_options()(
+        "test", new untyped_value(),
+        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
+        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
+        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
+        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo")
+      ("list", new untyped_value(),
+         "a list:\n      \t"
+             "item1, item2, item3, item4, item5, item6, item7, item8, item9, "
+             "item10, item11, item12, item13, item14, item15, item16, item17, item18")
+      ("well_formated", new untyped_value(), 
+                        "As you can see this is a very well formatted option description.\n"
+                        "You can do this for example:\n\n"
+                        "Values:\n"
+                        "  Value1: \tdoes this and that, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n"
+                        "  Value2: \tdoes something else, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n\n"
+                        "    This paragraph has a first line indent only, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla")
+      ;
+
+    stringstream ss;
+    ss << desc;
+    BOOST_CHECK_EQUAL(ss.str(),
+"  --test arg            foo foo foo foo foo foo foo foo foo foo foo foo foo \n"
+"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
+"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
+"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
+"                        foo\n"
+"  --list arg            a list:\n"
+"                              item1, item2, item3, item4, item5, item6, item7, \n"
+"                              item8, item9, item10, item11, item12, item13, \n"
+"                              item14, item15, item16, item17, item18\n"
+"  --well_formated arg   As you can see this is a very well formatted option \n"
+"                        description.\n"
+"                        You can do this for example:\n"
+"                        \n"
+"                        Values:\n"
+"                          Value1: does this and that, bla bla bla bla bla bla \n"
+"                                  bla bla bla bla bla bla bla bla bla\n"
+"                          Value2: does something else, bla bla bla bla bla bla \n"
+"                                  bla bla bla bla bla bla bla bla bla\n"
+"                        \n"
+"                            This paragraph has a first line indent only, bla \n"
+"                        bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n"
+   );
+}
+
+void test_formatting_description_length()
+{
+    {
+        options_description desc("",
+                                 options_description::m_default_line_length,
+                                 options_description::m_default_line_length / 2U);
+        desc.add_options()
+            ("an-option-that-sets-the-max", new untyped_value(), // > 40 available for desc
+            "this description sits on the same line, but wrapping should still work correctly")
+            ("a-long-option-that-would-leave-very-little-space-for-description", new untyped_value(),
+            "the description of the long opt, but placed on the next line\n"
+            "    \talso ensure that the tabulation works correctly when a"
+            " description size has been set");
+
+        stringstream ss;
+        ss << desc;
+        BOOST_CHECK_EQUAL(ss.str(),
+        "  --an-option-that-sets-the-max arg     this description sits on the same line,\n"
+        "                                        but wrapping should still work \n"
+        "                                        correctly\n"
+        "  --a-long-option-that-would-leave-very-little-space-for-description arg\n"
+        "                                        the description of the long opt, but \n"
+        "                                        placed on the next line\n"
+        "                                            also ensure that the tabulation \n"
+        "                                            works correctly when a description \n"
+        "                                            size has been set\n");
+    }
+    {
+        // the default behaviour reserves 23 (+1 space) characters for the
+        // option column; this shows that the min_description_length does not
+        // breach that.
+        options_description desc("",
+                                 options_description::m_default_line_length,
+                                 options_description::m_default_line_length - 10U); // leaves < 23 (default option space)
+        desc.add_options()
+            ("an-option-that-encroaches-description", new untyped_value(),
+            "this description should always be placed on the next line, and wrapping should continue as normal");
+
+        stringstream ss;
+        ss << desc;
+        BOOST_CHECK_EQUAL(ss.str(),
+        "  --an-option-that-encroaches-description arg\n"
+       //123456789_123456789_
+        "          this description should always be placed on the next line, and \n"
+        "          wrapping should continue as normal\n");
+    }
+}
+
+void test_long_default_value()
+{
+    options_description desc;
+    desc.add_options()
+        ("cfgfile,c",
+         value<string>()->default_value("/usr/local/etc/myprogramXXXXXXXXX/configuration.conf"),
+         "the configfile")
+       ;
+
+    stringstream ss;
+    ss << desc;
+    BOOST_CHECK_EQUAL(ss.str(),
+"  -c [ --cfgfile ] arg (=/usr/local/etc/myprogramXXXXXXXXX/configuration.conf)\n"
+"                                        the configfile\n"
+   );
+}
+
+void test_word_wrapping()
+{
+   options_description desc("Supported options");
+   desc.add_options()
+      ("help",    "this is a sufficiently long text to require word-wrapping")
+      ("prefix", value<string>()->default_value("/h/proj/tmp/dispatch"), "root path of the dispatch installation")
+      ("opt1",    "this_is_a_sufficiently_long_text_to_require_word-wrapping_but_cannot_be_wrapped")
+      ("opt2",    "this_is_a_sufficiently long_text_to_require_word-wrapping")
+      ("opt3",    "this_is_a sufficiently_long_text_to_require_word-wrapping_but_will_not_be_wrapped")
+      ;
+    stringstream ss;
+    ss << desc;    
+    BOOST_CHECK_EQUAL(ss.str(),
+"Supported options:\n"
+"  --help                               this is a sufficiently long text to \n"
+"                                       require word-wrapping\n"
+"  --prefix arg (=/h/proj/tmp/dispatch) root path of the dispatch installation\n"
+"  --opt1                               this_is_a_sufficiently_long_text_to_requ\n"
+"                                       ire_word-wrapping_but_cannot_be_wrapped\n"
+"  --opt2                               this_is_a_sufficiently \n"
+"                                       long_text_to_require_word-wrapping\n"
+"  --opt3                               this_is_a sufficiently_long_text_to_requ\n"
+"                                       ire_word-wrapping_but_will_not_be_wrappe\n"
+"                                       d\n"
+   );
+}
+
+void test_default_values()
+{
+   options_description desc("Supported options");
+   desc.add_options()
+      ("maxlength", value<double>()->default_value(.1, "0.1"), "Maximum edge length to keep.")
+      ;
+   stringstream ss;
+   ss << desc;    
+   BOOST_CHECK_EQUAL(ss.str(),
+"Supported options:\n"
+"  --maxlength arg (=0.1) Maximum edge length to keep.\n"
+   );   
+}
+
+void test_value_name()
+{
+    options_description desc("Supported options");
+    desc.add_options()
+        ("include", value<string>()->value_name("directory"), "Search for headers in 'directory'.")
+        ;
+
+    stringstream ss;
+    ss << desc;
+   BOOST_CHECK_EQUAL(ss.str(),
+"Supported options:\n"
+"  --include directory   Search for headers in 'directory'.\n"
+   );
+}
+
+
+int main(int, char* [])
+{
+    test_type();
+    test_approximation();
+    test_formatting();
+    test_formatting_description_length();
+    test_long_default_value();
+    test_word_wrapping();
+    test_default_values();
+    test_value_name();
+    return 0;
+}
+

libs/program_options/test/parsers_test.cpp

@@ -0,0 +1,327 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+using namespace boost::program_options;
+// We'll use po::value everywhere to workaround vc6 bug.
+namespace po = boost::program_options;
+
+#include <boost/function.hpp>
+using namespace boost;
+
+#include <sstream>
+#include <iostream>
+using namespace std;
+
+#if defined(__sun)
+#include <stdlib.h> // for putenv on solaris
+#else
+#include <cstdlib> // for putenv
+#endif
+
+#include "minitest.hpp"
+
+#define TEST_CHECK_THROW(expression, exception, description) \
+    try \
+    { \
+        expression; \
+        BOOST_ERROR(description);\
+        throw 10; \
+    } \
+    catch(exception &) \
+    { \
+    }
+
+pair<string, vector< vector<string> > > msp(const string& s1)
+{
+    return std::make_pair(s1, vector< vector<string> >());
+}
+
+
+pair<string, vector< vector<string> > > msp(const string& s1, const string& s2)
+{
+    vector< vector<string> > v(1);
+    v[0].push_back(s2);
+    return std::make_pair(s1, v);
+}
+
+void check_value(const option& option, const char* name, const char* value)
+{
+    BOOST_CHECK(option.string_key == name);
+    BOOST_REQUIRE(option.value.size() == 1);
+    BOOST_CHECK(option.value.front() == value);
+}
+
+vector<string> sv(const char* array[], unsigned size)
+{
+    vector<string> r;
+    for (unsigned i = 0; i < size; ++i)
+        r.push_back(array[i]);
+    return r;
+}
+
+pair<string, string> additional_parser(const std::string&)
+{
+    return pair<string, string>();
+}
+
+void test_command_line()
+{
+    // The following commented out blocks used to test parsing
+    // command line without syntax specification behaviour.
+    // It is disabled now and probably will never be enabled again:
+    // it is not possible to figure out what command line means without
+    // user's help.
+    #if 0
+    char* cmdline1[] = { "--a", "--b=12", "-f", "-g4", "-", "file" };
+
+    options_and_arguments a1 =
+        parse_command_line(cmdline1,
+                           cmdline1 + sizeof(cmdline1)/sizeof(cmdline1[0]));
+
+    BOOST_REQUIRE(a1.options().size() == 4);
+    BOOST_CHECK(a1.options()[0] == msp("a", ""));
+    BOOST_CHECK(a1.options()[1] == msp("b", "12"));
+    BOOST_CHECK(a1.options()[2] == msp("-f", ""));
+    BOOST_CHECK(a1.options()[3] == msp("-g", "4"));
+    BOOST_REQUIRE(a1.arguments().size() == 2);
+    BOOST_CHECK(a1.arguments()[0] == "-");
+    BOOST_CHECK(a1.arguments()[1] == "file");
+
+    char* cmdline2[] = { "--a", "--", "file" };
+
+    options_and_arguments a2 =
+        parse_command_line(cmdline2,
+                           cmdline2 + sizeof(cmdline2)/sizeof(cmdline2[0]));
+
+    BOOST_REQUIRE(a2.options().size() == 1);
+    BOOST_CHECK(a2.options()[0] == msp("a", ""));
+    BOOST_CHECK(a2.arguments().size() == 1);
+    BOOST_CHECK(a2.arguments()[0] == "file");
+    #endif
+    
+    options_description desc;
+    desc.add_options()
+        ("foo,f", new untyped_value(), "")
+        // Explicit qualification is a workaround for vc6
+        ("bar,b", po::value<std::string>(), "")
+        ("baz", new untyped_value())
+        ("plug*", new untyped_value())
+        ;
+    const char* cmdline3_[] = { "--foo=12", "-f4", "--bar=11", "-b4",
+                          "--plug3=10"};
+    vector<string> cmdline3 = sv(cmdline3_,
+                                 sizeof(cmdline3_)/sizeof(const char*));
+    vector<option> a3 = 
+        command_line_parser(cmdline3).options(desc).run().options;
+                       
+    BOOST_CHECK_EQUAL(a3.size(), 5u);
+
+    check_value(a3[0], "foo", "12");
+    check_value(a3[1], "foo", "4");
+    check_value(a3[2], "bar", "11");
+    check_value(a3[3], "bar", "4");
+    check_value(a3[4], "plug3", "10");
+
+    // Regression test: check that '0' as style is interpreted as 
+    // 'default_style'
+    vector<option> a4 = 
+        parse_command_line(sizeof(cmdline3_)/sizeof(const char*), cmdline3_, 
+                                                               desc, 0, additional_parser).options;
+
+    BOOST_CHECK_EQUAL(a4.size(), 4u);
+    check_value(a4[0], "foo", "4");
+    check_value(a4[1], "bar", "11");
+
+    // Check that we don't crash on empty values of type 'string'
+    const char* cmdline4[] = {"", "--open", ""};
+    options_description desc2;
+    desc2.add_options()
+        ("open", po::value<string>())
+        ;
+    variables_map vm;
+    po::store(po::parse_command_line(sizeof(cmdline4)/sizeof(const char*), const_cast<char**>(cmdline4), desc2), vm);
+
+    const char* cmdline5[] = {"", "-p7", "-o", "1", "2", "3", "-x8"};
+    options_description desc3;
+    desc3.add_options()
+        (",p", po::value<string>())
+        (",o", po::value<string>()->multitoken())
+        (",x", po::value<string>())
+        ;
+    vector<option> a5 = 
+        parse_command_line(sizeof(cmdline5)/sizeof(const char*), const_cast<char**>(cmdline5), 
+                                                                     desc3, 0, additional_parser).options;
+    BOOST_CHECK_EQUAL(a5.size(), 3u);
+    check_value(a5[0], "-p", "7");
+    BOOST_REQUIRE(a5[1].value.size() == 3);
+    BOOST_CHECK_EQUAL(a5[1].string_key, "-o");
+    BOOST_CHECK_EQUAL(a5[1].value[0], "1");
+    BOOST_CHECK_EQUAL(a5[1].value[1], "2");
+    BOOST_CHECK_EQUAL(a5[1].value[2], "3");
+    check_value(a5[2], "-x", "8");   
+
+
+    po::options_description desc4( "" );
+    desc4.add_options()
+        ( "multitoken,m",
+          po::value< std::vector< std::string > >()->multitoken(),
+          "values"
+            )
+        ( "file",
+          po::value< std::string >(),
+          "the file to process"
+            )
+        ;
+
+    po::positional_options_description p;
+    p.add( "file", 1 );
+
+    const char* cmdline6[] = {"", "-m", "token1", "token2", "--", "some_file"};
+    vector<option> a6 = 
+        command_line_parser(sizeof(cmdline6)/sizeof(const char*), const_cast<char**>(cmdline6)).options(desc4).positional(p)
+        .run().options;
+    BOOST_CHECK_EQUAL(a6.size(), 2u);
+    BOOST_REQUIRE(a6[0].value.size() == 2);
+    BOOST_CHECK_EQUAL(a6[0].string_key, "multitoken");
+    BOOST_CHECK_EQUAL(a6[0].value[0], "token1");
+    BOOST_CHECK_EQUAL(a6[0].value[1], "token2");
+    BOOST_CHECK_EQUAL(a6[1].string_key, "file");
+    BOOST_REQUIRE(a6[1].value.size() == 1);
+    BOOST_CHECK_EQUAL(a6[1].value[0], "some_file");
+}
+
+void test_config_file(const char* config_file)
+{
+    options_description desc;
+    desc.add_options()
+        ("gv1", new untyped_value)
+        ("gv2", new untyped_value)
+        ("empty_value", new untyped_value)
+        ("plug*", new untyped_value)
+        ("m1.v1", new untyped_value)
+        ("m1.v2", new untyped_value)
+        ("b", bool_switch())
+    ;
+
+    const char content1[] =
+    " gv1 = 0#asd\n"
+    "empty_value = \n"
+    "plug3 = 7\n"
+    "b = true\n"
+    "[m1]\n"
+    "v1 = 1\n"
+    "\n"
+    "v2 = 2\n"    
+    ;
+
+    stringstream ss(content1);
+    vector<option> a1 = parse_config_file(ss, desc).options;
+    BOOST_REQUIRE(a1.size() == 6);
+    check_value(a1[0], "gv1", "0");
+    check_value(a1[1], "empty_value", "");
+    check_value(a1[2], "plug3", "7");
+    check_value(a1[3], "b", "true");
+    check_value(a1[4], "m1.v1", "1");
+    check_value(a1[5], "m1.v2", "2");
+    
+    // same test, but now options come from file 
+    vector<option> a2 = parse_config_file<char>(config_file, desc).options;
+    BOOST_REQUIRE(a2.size() == 6);
+    check_value(a2[0], "gv1", "0");
+    check_value(a2[1], "empty_value", "");
+    check_value(a2[2], "plug3", "7");
+    check_value(a2[3], "b", "true");
+    check_value(a2[4], "m1.v1", "1");
+    check_value(a2[5], "m1.v2", "2");
+}
+
+void test_environment()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo", new untyped_value, "")
+        ("bar", new untyped_value, "")
+        ;
+
+#if defined(_WIN32) && ! defined(__BORLANDC__)
+    _putenv("PO_TEST_FOO=1");
+#else
+    putenv(const_cast<char*>("PO_TEST_FOO=1"));
+#endif
+    parsed_options p = parse_environment(desc, "PO_TEST_");
+
+    BOOST_REQUIRE(p.options.size() == 1);
+    BOOST_CHECK(p.options[0].string_key == "foo");
+    BOOST_REQUIRE(p.options[0].value.size() == 1);
+    BOOST_CHECK(p.options[0].value[0] == "1");
+
+    //TODO: since 'bar' does not allow a value, it cannot appear in environemt,
+    // which already has a value.
+}
+
+void test_unregistered()
+{
+    options_description desc;
+
+    const char* cmdline1_[] = { "--foo=12", "--bar", "1"};
+    vector<string> cmdline1 = sv(cmdline1_,
+                                 sizeof(cmdline1_)/sizeof(const char*));
+    vector<option> a1 = 
+        command_line_parser(cmdline1).options(desc).allow_unregistered().run()
+        .options;
+
+    BOOST_REQUIRE(a1.size() == 3);
+    BOOST_CHECK(a1[0].string_key == "foo");
+    BOOST_CHECK(a1[0].unregistered == true);
+    BOOST_REQUIRE(a1[0].value.size() == 1);
+    BOOST_CHECK(a1[0].value[0] == "12");
+    BOOST_CHECK(a1[1].string_key == "bar");
+    BOOST_CHECK(a1[1].unregistered == true);
+    BOOST_CHECK(a1[2].string_key == "");
+    BOOST_CHECK(a1[2].unregistered == false);
+    
+
+    vector<string> a2 = collect_unrecognized(a1, include_positional);
+    BOOST_CHECK(a2[0] == "--foo=12");
+    BOOST_CHECK(a2[1] == "--bar");
+    BOOST_CHECK(a2[2] == "1");
+
+    // Test that storing unregisted options has no effect
+    variables_map vm;
+    
+    store(command_line_parser(cmdline1).options(desc).
+          allow_unregistered().run(),
+          vm);
+
+    BOOST_CHECK_EQUAL(vm.size(), 0u);   
+
+
+    const char content1[] =
+    "gv1 = 0\n"
+    "[m1]\n"
+    "v1 = 1\n"
+    ;
+
+    stringstream ss(content1);
+    vector<option> a3 = parse_config_file(ss, desc, true).options;
+    BOOST_REQUIRE(a3.size() == 2);
+    cout << "XXX" << a3[0].value.front() << "\n";
+    check_value(a3[0], "gv1", "0");
+    check_value(a3[1], "m1.v1", "1");
+}
+
+int main(int, char* av[])
+{
+    test_command_line();
+    test_config_file(av[1]);
+    test_environment();
+    test_unregistered();
+    return 0;
+}
+

libs/program_options/test/positional_options_test.cpp

@@ -0,0 +1,91 @@
+// Copyright Vladimir Prus 2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/program_options/positional_options.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/parsers.hpp>
+using namespace boost::program_options;
+// We'll use po::value everywhere to workaround vc6 bug.
+namespace po = boost::program_options;
+
+
+#include <boost/limits.hpp>
+
+#include "minitest.hpp"
+
+#include <vector>
+using namespace std;
+
+void test_positional_options()
+{
+    positional_options_description p;
+    p.add("first", 1);
+
+    BOOST_CHECK_EQUAL(p.max_total_count(), 1u);
+    BOOST_CHECK_EQUAL(p.name_for_position(0), "first");
+
+    p.add("second", 2);
+
+    BOOST_CHECK_EQUAL(p.max_total_count(), 3u);
+    BOOST_CHECK_EQUAL(p.name_for_position(0), "first");
+    BOOST_CHECK_EQUAL(p.name_for_position(1), "second");
+    BOOST_CHECK_EQUAL(p.name_for_position(2), "second");
+
+    p.add("third", -1);
+
+    BOOST_CHECK_EQUAL(p.max_total_count(), (std::numeric_limits<unsigned>::max)());
+    BOOST_CHECK_EQUAL(p.name_for_position(0), "first");
+    BOOST_CHECK_EQUAL(p.name_for_position(1), "second");
+    BOOST_CHECK_EQUAL(p.name_for_position(2), "second");
+    BOOST_CHECK_EQUAL(p.name_for_position(3), "third");
+    BOOST_CHECK_EQUAL(p.name_for_position(10000), "third");
+}
+
+void test_parsing()
+{
+    options_description desc;
+    desc.add_options()
+        ("first", po::value<int>())
+        ("second", po::value<int>())
+        ("input-file", po::value< vector<string> >())
+        ("some-other", po::value<string>())
+    ;
+
+    positional_options_description p;
+    p.add("input-file", 2).add("some-other", 1);
+
+    vector<string> args;
+    args.push_back("--first=10");
+    args.push_back("file1");
+    args.push_back("--second=10");
+    args.push_back("file2");
+    args.push_back("file3");
+
+    // Check that positional options are handled.
+    parsed_options parsed = 
+        command_line_parser(args).options(desc).positional(p).run();
+
+    BOOST_REQUIRE(parsed.options.size() == 5);
+    BOOST_CHECK_EQUAL(parsed.options[1].string_key, "input-file");
+    BOOST_CHECK_EQUAL(parsed.options[1].value[0], "file1");
+    BOOST_CHECK_EQUAL(parsed.options[3].string_key, "input-file");
+    BOOST_CHECK_EQUAL(parsed.options[3].value[0], "file2");
+    BOOST_CHECK_EQUAL(parsed.options[4].value[0], "file3");
+
+    args.push_back("file4");
+
+    // Check that excessive number of positional options is detected.
+    BOOST_CHECK_THROW(command_line_parser(args).options(desc).positional(p)
+                      .run(),
+                      too_many_positional_options_error);
+}
+
+int main(int, char* [])
+{
+    test_positional_options();
+    test_parsing();
+    return 0;
+}
+

libs/program_options/test/program_options_size_test.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+import os
+import string
+
+
+call = "   hook(10);\n";
+call = "   hook(10); hook2(10);hook3(0);hook4(0);\n";
+
+def run_test(num_calls, compiler_command):
+   f = open("program_options_test.cpp", "w")
+   f.write("""#include <boost/program_options.hpp>
+using namespace boost::program_options;   
+
+void do_it()
+{
+   boost::program_options::options_description desc;
+   desc.add_options()
+""")
+   for i in range(0, num_calls):
+      f.write("(\"opt%d\", value<int>())\n")
+   f.write(";\n}\n")   
+   f.close()
+   os.system(compiler_command + " -c -save-temps -I /home/ghost/Work/Boost/boost-svn program_options_test.cpp")
+
+   nm = os.popen("nm -S program_options_test.o")
+   for l in nm:
+      if string.find(l, "Z5do_itv") != -1:
+         break
+   size = int(string.split(l)[1], 16)
+   return size
+
+def run_tests(range, compiler_command):
+
+   last_size = None
+   first_size = None
+   for num in range:
+      size = run_test(num, compiler_command)
+      if last_size:
+         print "%2d calls: %5d bytes (+ %d)" % (num, size, size-last_size)
+      else:
+         print "%2d calls: %5d bytes" % (num, size)
+         first_size = size
+      last_size = size
+   print "Avarage: ", (last_size-first_size)/(range[-1]-range[0])
+
+if __name__ == '__main__':
+   for compiler in [ "g++ -Os", "g++ -O3"]:
+      print "****", compiler, "****"
+      run_tests(range(1, 20), compiler)
+
+
+ 

libs/program_options/test/required_test.cfg

@@ -0,0 +1 @@
+cfgfile = file.cfg

libs/program_options/test/required_test.cpp

@@ -0,0 +1,98 @@
+// Copyright Sascha Ochsenknecht 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/program_options.hpp>
+using namespace boost::program_options;
+
+#include <string>
+#include <iostream>
+#include <fstream>
+using namespace std;
+
+#include "minitest.hpp"
+
+
+void required_throw_test()
+{
+   options_description          opts;
+   opts.add_options()
+     ("cfgfile,c", value<string>()->required(), "the configfile")
+     ("fritz,f",   value<string>()->required(), "the output file")
+   ;
+
+   variables_map vm;
+   bool throwed = false;
+   {
+      // This test must throw exception
+      string cmdline = "prg -f file.txt";
+      vector< string > tokens =  split_unix(cmdline);
+      throwed = false;
+      try {
+         store(command_line_parser(tokens).options(opts).run(), vm);
+         notify(vm);    
+      } 
+      catch (required_option& e) {
+         BOOST_CHECK_EQUAL(e.what(), string("the option '--cfgfile' is required but missing"));
+         throwed = true;
+      }      
+      BOOST_CHECK(throwed);
+   }
+   
+   {
+      // This test mustn't throw exception
+      string cmdline = "prg -c config.txt";
+      vector< string > tokens =  split_unix(cmdline);
+      throwed = false;
+      try {
+         store(command_line_parser(tokens).options(opts).run(), vm);
+         notify(vm);    
+      } 
+      catch (required_option& e) {
+         throwed = true;
+      }
+      BOOST_CHECK(!throwed);
+   }
+}
+
+
+
+void simple_required_test(const char* config_file)
+{
+   options_description          opts;
+   opts.add_options()
+     ("cfgfile,c", value<string>()->required(), "the configfile")
+     ("fritz,f",   value<string>()->required(), "the output file")
+   ;
+
+   variables_map vm;
+   bool throwed = false;
+   {
+      // This test must throw exception
+      string cmdline = "prg -f file.txt";
+      vector< string > tokens =  split_unix(cmdline);
+      throwed = false;
+      try {
+         // options coming from different sources
+         store(command_line_parser(tokens).options(opts).run(), vm);
+         store(parse_config_file<char>(config_file, opts), vm);
+         notify(vm);    
+      } 
+      catch (required_option& e) {
+         throwed = true;
+      }      
+      BOOST_CHECK(!throwed);
+   }
+}
+
+
+
+int main(int /*argc*/, char* av[])
+{  
+   required_throw_test();
+   simple_required_test(av[1]);
+   
+   return 0;
+}
+

libs/program_options/test/split_test.cpp

@@ -0,0 +1,189 @@
+// Copyright Sascha Ochsenknecht 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/cmdline.hpp>
+using namespace boost::program_options;
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cassert>
+using namespace std;
+
+#include "minitest.hpp"
+
+void check_value(const string& option, const string& value)
+{
+    BOOST_CHECK(option == value);
+}
+
+void split_whitespace(const options_description& description)
+{
+
+   const char* cmdline = "prg --input input.txt \r --optimization 4  \t  --opt \n  option";
+   
+   vector< string > tokens =  split_unix(cmdline, " \t\n\r");
+   
+   BOOST_REQUIRE(tokens.size() == 7);
+   
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "option");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+void split_equalsign(const options_description& description)
+{
+
+   const char* cmdline = "prg --input=input.txt  --optimization=4 --opt=option";
+   
+   vector< string > tokens =  split_unix(cmdline, "= ");
+ 
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "option");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+void split_semi(const options_description& description)
+{
+
+   const char* cmdline = "prg;--input input.txt;--optimization 4;--opt option";
+   
+   vector< string > tokens =  split_unix(cmdline, "; ");
+   
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "option");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+void split_quotes(const options_description& description)
+{
+   const char* cmdline = "prg --input \"input.txt input.txt\" --optimization 4 --opt \"option1 option2\"";
+   
+   vector< string > tokens =  split_unix(cmdline, " ");
+ 
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input.txt input.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "option1 option2");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+void split_escape(const options_description& description)
+{
+   const char* cmdline = "prg --input \\\"input.txt\\\" --optimization 4 --opt \\\"option1\\ option2\\\"";
+   
+   vector< string > tokens =  split_unix(cmdline, " ");
+  
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "\"input.txt\"");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "\"option1 option2\"");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+
+void split_single_quote(const options_description& description)
+{
+   const char* cmdline = "prg --input 'input.txt input.txt' --optimization 4 --opt 'option1 option2'";
+   
+   vector< string > tokens =  split_unix(cmdline, " ", "'");
+ 
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input.txt input.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "option1 option2");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+void split_defaults(const options_description& description)
+{
+   const char* cmdline = "prg --input \t \'input file.txt\' \t   --optimization 4 --opt \\\"option1\\ option2\\\"";
+   
+   vector< string > tokens =  split_unix(cmdline);
+  
+   BOOST_REQUIRE(tokens.size() == 7);
+   check_value(tokens[0], "prg");
+   check_value(tokens[1], "--input");
+   check_value(tokens[2], "input file.txt");
+   check_value(tokens[3], "--optimization");
+   check_value(tokens[4], "4");
+   check_value(tokens[5], "--opt");
+   check_value(tokens[6], "\"option1 option2\"");
+
+   variables_map vm;  
+   store(command_line_parser(tokens).options(description).run(), vm);
+   notify(vm);
+}
+
+int main(int /*ac*/, char** /*av*/)
+{
+   options_description desc;
+   desc.add_options()
+        ("input,i", value<string>(), "the input file")
+        ("optimization,O", value<unsigned>(), "optimization level")
+        ("opt,o", value<string>(), "misc option")
+      ;
+
+   split_whitespace(desc);
+   split_equalsign(desc);
+   split_semi(desc);
+   split_quotes(desc);
+   split_escape(desc);
+   split_single_quote(desc);
+   split_defaults(desc);
+   
+   return 0;
+}

libs/program_options/test/test_convert.cpp

@@ -0,0 +1,146 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cstring>
+#include <cassert>
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <boost/progress.hpp>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+
+#include <boost/program_options/detail/convert.hpp>
+#include <boost/program_options/detail/utf8_codecvt_facet.hpp>
+
+#include "minitest.hpp"
+
+using namespace std;
+
+string file_content(const string& filename)
+{
+    ifstream ifs(filename.c_str());
+    assert(ifs);
+    
+    stringstream ss;
+    ss << ifs.rdbuf();
+    
+    return ss.str();
+}
+
+// A version of from_8_bit which does not use functional object, for
+// performance comparison.
+std::wstring from_8_bit_2(const std::string& s, 
+                          const codecvt<wchar_t, char, mbstate_t>& cvt)
+{
+    std::wstring result;
+
+
+    std::mbstate_t state = std::mbstate_t();
+    
+    const char* from = s.data();
+    const char* from_end = s.data() + s.size();
+    // The interace of cvt is not really iterator-like, and it's
+    // not possible the tell the required output size without the conversion.
+    // All we can is convert data by pieces.
+    while(from != from_end) {
+            
+        // std::basic_string does not provide non-const pointers to the data,
+        // so converting directly into string is not possible.
+        wchar_t buffer[32];
+            
+        wchar_t* to_next = buffer;
+        // Try to convert remaining input.
+        std::codecvt_base::result r = 
+            cvt.in(state, from, from_end, from, buffer, buffer + 32, to_next);
+        
+        if (r == std::codecvt_base::error)
+            throw logic_error("character conversion failed");
+        // 'partial' is not an error, it just means not all source characters
+        // we converted. However, we need to check that at least one new target
+        // character was produced. If not, it means the source data is 
+        // incomplete, and since we don't have extra data to add to source, it's
+        // error.
+        if (to_next == buffer)
+            throw logic_error("character conversion failed");
+
+        // Add converted characters
+        result.append(buffer, to_next);
+    }
+
+    return result;        
+}
+
+
+void test_convert(const std::string& input, 
+                  const std::string& expected_output)
+{
+    boost::program_options::detail::utf8_codecvt_facet facet;
+    
+    std::wstring output;
+    { 
+        boost::progress_timer t;
+        for (int i = 0; i < 10000; ++i)
+            output = boost::from_8_bit(
+                input,
+                facet);
+    }
+
+    {
+        boost::progress_timer t;
+        for (int i = 0; i < 10000; ++i)
+            output = from_8_bit_2(
+                input,
+                facet);
+    }
+
+    BOOST_CHECK(output.size()*2 == expected_output.size());
+
+    for(unsigned i = 0; i < output.size(); ++i) {
+
+        {
+            unsigned low = output[i];
+            low &= 0xFF;
+            unsigned low2 = expected_output[2*i];
+            low2 &= 0xFF;
+            BOOST_CHECK(low == low2);
+        }
+        {        
+            unsigned high = output[i];
+            high >>= 8;
+            high &= 0xFF;
+            unsigned high2 = expected_output[2*i+1];            
+            BOOST_CHECK(high == high2);
+        }
+    }
+
+    string ref = boost::to_8_bit(output, facet);
+
+    BOOST_CHECK(ref == input);
+}
+
+int main(int ac, char* av[])
+{       
+    std::string input = file_content("utf8.txt");
+    std::string expected = file_content("ucs2.txt");
+
+    test_convert(input, expected);
+    
+    if (ac > 1) {
+        cout << "Trying to convert the command line argument\n";
+    
+        locale::global(locale(""));
+        std::wstring w = boost::from_local_8_bit(av[1]);
+ 
+        cout << "Got something, printing decimal code point values\n";
+        for (unsigned i = 0; i < w.size(); ++i) {
+            cout << (unsigned)w[i] << "\n";
+        }
+        
+    }
+    
+    return 0;
+}

libs/program_options/test/unicode_test.cpp

@@ -0,0 +1,163 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/detail/utf8_codecvt_facet.hpp>
+using namespace boost::program_options;
+// We'll use po::value everywhere to workaround vc6 bug.
+namespace po = boost::program_options;
+
+#include <boost/function.hpp>
+using namespace boost;
+
+#include <sstream>
+using namespace std;
+
+#include "minitest.hpp"
+
+// Test that unicode input is forwarded to unicode option without
+// problems.
+void test_unicode_to_unicode()
+{
+    options_description desc;
+
+    desc.add_options()
+        ("foo", po::wvalue<wstring>(), "unicode option")
+        ;
+
+    vector<wstring> args;
+    args.push_back(L"--foo=\x044F");
+
+    variables_map vm;
+    basic_parsed_options<wchar_t> parsed = 
+        wcommand_line_parser(args).options(desc).run();
+    store(parsed, vm);
+
+    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");
+    BOOST_CHECK(parsed.options[0].original_tokens.size() == 1);
+    BOOST_CHECK(parsed.options[0].original_tokens[0] == L"--foo=\x044F");
+}
+
+// Test that unicode input is property converted into
+// local 8 bit string. To test this, make local 8 bit encoding
+// be utf8.
+void test_unicode_to_native()
+{
+    std::codecvt<wchar_t, char, mbstate_t>* facet = 
+        new boost::program_options::detail::utf8_codecvt_facet;
+    locale::global(locale(locale(), facet));
+
+    options_description desc;
+
+    desc.add_options()
+        ("foo", po::value<string>(), "unicode option")
+        ;
+
+    vector<wstring> args;
+    args.push_back(L"--foo=\x044F");
+
+    variables_map vm;
+    store(wcommand_line_parser(args).options(desc).run(), vm);
+
+    BOOST_CHECK(vm["foo"].as<string>() == "\xD1\x8F");    
+}
+
+void test_native_to_unicode()
+{
+    std::codecvt<wchar_t, char, mbstate_t>* facet = 
+        new boost::program_options::detail::utf8_codecvt_facet;
+    locale::global(locale(locale(), facet));
+
+    options_description desc;
+
+    desc.add_options()
+        ("foo", po::wvalue<wstring>(), "unicode option")
+        ;
+
+    vector<string> args;
+    args.push_back("--foo=\xD1\x8F");
+
+    variables_map vm;
+    store(command_line_parser(args).options(desc).run(), vm);
+
+    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");    
+}
+
+vector<wstring> sv(const wchar_t* array[], unsigned size)
+{
+    vector<wstring> r;
+    for (unsigned i = 0; i < size; ++i)
+        r.push_back(array[i]);
+    return r;
+}
+
+void check_value(const woption& option, const char* name, const wchar_t* value)
+{
+    BOOST_CHECK(option.string_key == name);
+    BOOST_REQUIRE(option.value.size() == 1);
+    BOOST_CHECK(option.value.front() == value);
+}
+
+void test_command_line()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo,f", new untyped_value(), "")
+        // Explicit qualification is a workaround for vc6
+        ("bar,b", po::value<std::string>(), "")
+        ("baz", new untyped_value())
+        ("plug*", new untyped_value())
+        ;
+
+    const wchar_t* cmdline4_[] = { L"--foo=1\u0FF52", L"-f4", L"--bar=11",
+                             L"-b4", L"--plug3=10"};
+    vector<wstring> cmdline4 = sv(cmdline4_,
+                                  sizeof(cmdline4_)/sizeof(cmdline4_[0]));
+    vector<woption> a4 = 
+        wcommand_line_parser(cmdline4).options(desc).run().options;
+
+    BOOST_REQUIRE(a4.size() == 5);
+
+    check_value(a4[0], "foo", L"1\u0FF52");
+    check_value(a4[1], "foo", L"4");
+    check_value(a4[2], "bar", L"11");
+}
+
+// Since we've already tested conversion between parser encoding and
+// option encoding, all we need to check for config file is that
+// when reading wistream, it generates proper UTF8 data.
+void test_config_file()
+{
+    std::codecvt<wchar_t, char, mbstate_t>* facet = 
+        new boost::program_options::detail::utf8_codecvt_facet;
+    locale::global(locale(locale(), facet));
+
+    options_description desc;
+
+    desc.add_options()
+        ("foo", po::value<string>(), "unicode option")
+        ;
+
+    std::wstringstream stream(L"foo = \x044F");
+
+    variables_map vm;
+    store(parse_config_file(stream, desc), vm);
+
+    BOOST_CHECK(vm["foo"].as<string>() == "\xD1\x8F");    
+}
+
+int main(int, char* [])
+{
+    test_unicode_to_unicode();
+    test_unicode_to_native();
+    test_native_to_unicode();
+    test_command_line();
+    test_config_file();
+    return 0;
+}
+

libs/program_options/test/unrecognized_test.cpp

@@ -0,0 +1,88 @@
+// Copyright Sascha Ochsenknecht 2009.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/cmdline.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/detail/cmdline.hpp>
+using namespace boost::program_options;
+using boost::program_options::detail::cmdline;
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cassert>
+using namespace std;
+
+#include "minitest.hpp"
+
+
+// Test free function collect_unrecognized()
+//
+//  it collects the tokens of all not registered options. It can be used
+//  to pass them to an own parser implementation
+
+
+
+void test_unrecognize_cmdline() 
+{
+   options_description desc;
+   
+   string content = "prg --input input.txt --optimization 4 --opt option";   
+   vector< string > tokens =  split_unix(content);
+
+   cmdline cmd(tokens);
+   cmd.set_options_description(desc);
+   cmd.allow_unregistered();
+
+   vector< option > opts = cmd.run();
+   vector< string > result = collect_unrecognized(opts, include_positional);
+   
+   BOOST_CHECK_EQUAL(result.size(), 7);
+   BOOST_CHECK_EQUAL(result[0], "prg");
+   BOOST_CHECK_EQUAL(result[1], "--input");
+   BOOST_CHECK_EQUAL(result[2], "input.txt");
+   BOOST_CHECK_EQUAL(result[3], "--optimization");
+   BOOST_CHECK_EQUAL(result[4], "4");
+   BOOST_CHECK_EQUAL(result[5], "--opt");
+   BOOST_CHECK_EQUAL(result[6], "option");
+}
+
+
+
+void test_unrecognize_config() 
+{
+
+   options_description desc;
+   
+   string content  =
+    " input = input.txt\n"
+    " optimization = 4\n"
+    " opt = option\n"
+    ;
+
+   stringstream ss(content);
+   vector< option > opts = parse_config_file(ss, desc, true).options;
+   vector< string > result = collect_unrecognized(opts, include_positional);
+   
+   BOOST_CHECK_EQUAL(result.size(), 6);
+   BOOST_CHECK_EQUAL(result[0], "input");
+   BOOST_CHECK_EQUAL(result[1], "input.txt");
+   BOOST_CHECK_EQUAL(result[2], "optimization");
+   BOOST_CHECK_EQUAL(result[3], "4");
+   BOOST_CHECK_EQUAL(result[4], "opt");
+   BOOST_CHECK_EQUAL(result[5], "option");
+}
+
+
+
+int main(int /*ac*/, char** /*av*/)
+{
+   test_unrecognize_cmdline();
+   test_unrecognize_config();
+
+   return 0;
+}

libs/program_options/test/variable_map_test.cpp

@@ -0,0 +1,290 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/program_options/detail/utf8_codecvt_facet.hpp>
+using namespace boost::program_options;
+// We'll use po::value everywhere to workaround vc6 bug.
+namespace po = boost::program_options;
+
+#include <boost/function.hpp>
+using namespace boost;
+
+#include <sstream>
+using namespace std;
+
+#include "minitest.hpp"
+
+vector<string> sv(const char* array[], unsigned size)
+{
+    vector<string> r;
+    for (unsigned i = 0; i < size; ++i)
+        r.push_back(array[i]);
+    return r;
+}
+
+void test_variable_map()
+{
+    options_description desc;
+    desc.add_options()
+        ("foo,f", new untyped_value)
+        ("bar,b", po::value<string>())
+        ("biz,z", po::value<string>())
+        ("baz", new untyped_value())
+        ("output,o", new untyped_value(), "")
+        ;
+    const char* cmdline3_[] = { "--foo='12'", "--bar=11", "-z3", "-ofoo" };
+    vector<string> cmdline3 = sv(cmdline3_,
+                                 sizeof(cmdline3_)/sizeof(const char*));
+    parsed_options a3 = command_line_parser(cmdline3).options(desc).run();
+    variables_map vm;
+    store(a3, vm);
+    notify(vm);
+    BOOST_REQUIRE(vm.size() == 4);
+    BOOST_CHECK(vm["foo"].as<string>() == "'12'");
+    BOOST_CHECK(vm["bar"].as<string>() == "11");
+    BOOST_CHECK(vm.count("biz") == 1);
+    BOOST_CHECK(vm["biz"].as<string>() == "3");
+    BOOST_CHECK(vm["output"].as<string>() == "foo");
+
+    int i;
+    desc.add_options()
+    ("zee", bool_switch(), "")
+    ("zak", po::value<int>(&i), "")
+    ("opt", bool_switch(), "");
+
+    const char* cmdline4_[] = { "--zee", "--zak=13" };
+    vector<string> cmdline4 = sv(cmdline4_,
+                                 sizeof(cmdline4_)/sizeof(const char*));
+    parsed_options a4 = command_line_parser(cmdline4).options(desc).run();
+
+    variables_map vm2;
+    store(a4, vm2);
+    notify(vm2);
+    BOOST_REQUIRE(vm2.size() == 3);
+    BOOST_CHECK(vm2["zee"].as<bool>() == true);
+    BOOST_CHECK(vm2["zak"].as<int>() == 13);
+    BOOST_CHECK(vm2["opt"].as<bool>() == false);
+    BOOST_CHECK(i == 13);
+
+    options_description desc2;
+    desc2.add_options()
+    ("vee", po::value<string>()->default_value("42"))
+    ("voo", po::value<string>())
+    ("iii", po::value<int>()->default_value(123))
+    ;
+    const char* cmdline5_[] = { "--voo=1" };
+    vector<string> cmdline5 = sv(cmdline5_,
+                                 sizeof(cmdline5_)/sizeof(const char*));
+    parsed_options a5 = command_line_parser(cmdline5).options(desc2).run();
+
+    variables_map vm3;
+    store(a5, vm3);
+    notify(vm3);
+    BOOST_REQUIRE(vm3.size() == 3);
+    BOOST_CHECK(vm3["vee"].as<string>() == "42");
+    BOOST_CHECK(vm3["voo"].as<string>() == "1");
+    BOOST_CHECK(vm3["iii"].as<int>() == 123);
+
+    options_description desc3;
+    desc3.add_options()
+    ("imp", po::value<int>()->implicit_value(100))
+    ("iim", po::value<int>()->implicit_value(200)->default_value(201))
+    ("mmp,m", po::value<int>()->implicit_value(123)->default_value(124))
+    ("foo", po::value<int>())
+    ;
+    /* The -m option is implicit. It does not have value in inside the token,
+       and we should not grab the next token.  */
+    const char* cmdline6_[] = {  "--imp=1", "-m", "--foo=1" };
+    vector<string> cmdline6 = sv(cmdline6_,
+                                 sizeof(cmdline6_)/sizeof(const char*));
+    parsed_options a6 = command_line_parser(cmdline6).options(desc3).run();
+
+    variables_map vm4;
+    store(a6, vm4);
+    notify(vm4);
+    BOOST_REQUIRE(vm4.size() == 4);
+    BOOST_CHECK(vm4["imp"].as<int>() == 1);
+    BOOST_CHECK(vm4["iim"].as<int>() == 201);
+    BOOST_CHECK(vm4["mmp"].as<int>() == 123);
+}
+
+int stored_value;
+void notifier(const vector<int>& v)
+{
+    stored_value = v.front();
+}
+
+void test_semantic_values()
+{
+    options_description desc;
+    desc.add_options()
+    ("foo", new untyped_value())
+    ("bar", po::value<int>())
+    ("biz", po::value< vector<string> >())
+    ("baz", po::value< vector<string> >()->multitoken())
+    ("int", po::value< vector<int> >()->notifier(&notifier))
+    ;
+
+       
+    parsed_options parsed(&desc);
+    vector<option>& options = parsed.options;
+    vector<string> v;
+    v.push_back("q");
+    options.push_back(option("foo", vector<string>(1, "1")));
+    options.push_back(option("biz", vector<string>(1, "a")));
+    options.push_back(option("baz", v));
+    options.push_back(option("bar", vector<string>(1, "1")));
+    options.push_back(option("biz", vector<string>(1, "b x")));
+    v.push_back("w");
+    options.push_back(option("baz", v));
+
+    variables_map vm;
+    store(parsed, vm);
+    notify(vm);
+    BOOST_REQUIRE(vm.count("biz") == 1);
+    BOOST_REQUIRE(vm.count("baz") == 1);
+    const vector<string> av = vm["biz"].as< vector<string> >();
+    const vector<string> av2 = vm["baz"].as< vector<string> >();
+    string exp1[] = { "a", "b x" };
+    BOOST_CHECK(av == vector<string>(exp1, exp1 + 2));
+    string exp2[] = { "q", "q", "w" };
+    BOOST_CHECK(av2 == vector<string>(exp2, exp2 + 3));
+
+    options.push_back(option("int", vector<string>(1, "13")));
+
+    variables_map vm2;
+    store(parsed, vm2);
+    notify(vm2);
+    BOOST_REQUIRE(vm2.count("int") == 1);
+    BOOST_CHECK(vm2["int"].as< vector<int> >() == vector<int>(1, 13));
+    BOOST_CHECK_EQUAL(stored_value, 13);
+
+    vector<option> saved_options = options;
+    
+    options.push_back(option("bar", vector<string>(1, "2")));
+    variables_map vm3;
+    BOOST_CHECK_THROW(store(parsed, vm3), multiple_occurrences);
+
+    options = saved_options;
+    // Now try passing two int in one 'argv' element.
+    // This should not work.
+    options.push_back(option("int", vector<string>(1, "2 3")));
+    variables_map vm4;
+    BOOST_CHECK_THROW(store(parsed, vm4), validation_error);
+}
+
+void test_priority()
+{
+    options_description desc;
+    desc.add_options()
+    // Value of this option will be specified in two sources,
+    // and only first one should be used.
+    ("first", po::value< vector<int > >())
+    // Value of this option will have default value in the first source,
+    // and explicit assignment in the second, so the second should be used.
+    ("second", po::value< vector<int > >()->default_value(vector<int>(1, 1), ""))
+    ("aux", po::value< vector<int > >())
+     // This will have values in both sources, and values should be combined
+    ("include", po::value< vector<int> >()->composing())
+    ;
+
+    const char* cmdline1_[] = { "--first=1", "--aux=10", "--first=3", "--include=1" };
+    vector<string> cmdline1 = sv(cmdline1_, 
+                                 sizeof(cmdline1_)/sizeof(const char*));
+
+    parsed_options p1 = command_line_parser(cmdline1).options(desc).run();
+
+    const char* cmdline2_[] = { "--first=12", "--second=7", "--include=7" };
+    vector<string> cmdline2 = sv(cmdline2_, 
+                                 sizeof(cmdline2_)/sizeof(const char*));
+
+    parsed_options p2 = command_line_parser(cmdline2).options(desc).run();
+
+    variables_map vm;
+    store(p1, vm);
+
+    BOOST_REQUIRE(vm.count("first") == 1);    
+    BOOST_REQUIRE(vm["first"].as< vector<int> >().size() == 2);
+    BOOST_CHECK_EQUAL(vm["first"].as< vector<int> >()[0], 1);
+    BOOST_CHECK_EQUAL(vm["first"].as< vector<int> >()[1], 3);
+
+    BOOST_REQUIRE(vm.count("second") == 1);    
+    BOOST_REQUIRE(vm["second"].as< vector<int> >().size() == 1);
+    BOOST_CHECK_EQUAL(vm["second"].as< vector<int> >()[0], 1);
+
+    store(p2, vm);
+
+    // Value should not change.
+    BOOST_REQUIRE(vm.count("first") == 1);    
+    BOOST_REQUIRE(vm["first"].as< vector<int> >().size() == 2);
+    BOOST_CHECK_EQUAL(vm["first"].as< vector<int> >()[0], 1);
+    BOOST_CHECK_EQUAL(vm["first"].as< vector<int> >()[1], 3);
+
+    // Value should change to 7
+    BOOST_REQUIRE(vm.count("second") == 1);    
+    BOOST_REQUIRE(vm["second"].as< vector<int> >().size() == 1);
+    BOOST_CHECK_EQUAL(vm["second"].as< vector<int> >()[0], 7);
+
+    BOOST_REQUIRE(vm.count("include") == 1);
+    BOOST_REQUIRE(vm["include"].as< vector<int> >().size() == 2);
+    BOOST_CHECK_EQUAL(vm["include"].as< vector<int> >()[0], 1);
+    BOOST_CHECK_EQUAL(vm["include"].as< vector<int> >()[1], 7);
+}
+
+void test_multiple_assignments_with_different_option_description()
+{
+    // Test that if we store option twice into the same variable_map,
+    // and some of the options stored the first time are not present
+    // in the options descrription provided the second time, we don't crash.
+
+    options_description desc1("");    
+    desc1.add_options()
+        ("help,h", "")
+        ("includes", po::value< vector<string> >()->composing(), "");
+        ;
+
+    options_description desc2("");
+    desc2.add_options()
+        ("output,o", "");
+
+    vector<string> input1;
+    input1.push_back("--help");
+    input1.push_back("--includes=a");
+    parsed_options p1 = command_line_parser(input1).options(desc1).run();
+
+    vector<string> input2;
+    input1.push_back("--output");
+    parsed_options p2 = command_line_parser(input2).options(desc2).run();
+
+    vector<string> input3;
+    input3.push_back("--includes=b");
+    parsed_options p3 = command_line_parser(input3).options(desc1).run();
+
+
+    variables_map vm;
+    store(p1, vm);
+    store(p2, vm);
+    store(p3, vm);
+
+    BOOST_REQUIRE(vm.count("help") == 1);
+    BOOST_REQUIRE(vm.count("includes") == 1);
+    BOOST_CHECK_EQUAL(vm["includes"].as< vector<string> >()[0], "a");
+    BOOST_CHECK_EQUAL(vm["includes"].as< vector<string> >()[1], "b");
+
+} 
+
+int main(int, char* [])
+{
+    test_variable_map();
+    test_semantic_values();
+    test_priority();
+    test_multiple_assignments_with_different_option_description();
+    return 0;
+}
+

libs/program_options/test/winmain.cpp

@@ -0,0 +1,74 @@
+// Copyright Vladimir Prus 2002-2004.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if defined(_WIN32)
+#include <string>
+#include <vector>
+#include <cctype>
+#include <iostream>
+#include <stdlib.h>
+
+using namespace std;
+
+#include <boost/program_options/parsers.hpp>
+using namespace boost::program_options;
+
+void check_equal(const std::vector<string>& actual, char **expected, int n)
+{
+    if (actual.size() != n)
+    {
+        std::cerr << "Size mismatch between expected and actual data\n";
+        abort();
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        if (actual[i] != expected[i])
+        {
+            std::cerr << "Unexpected content\n";
+            abort();
+        }
+    }
+}
+
+#include <boost/preprocessor/cat.hpp>
+
+void test_winmain()
+{
+
+#define C ,
+#define TEST(input, expected) \
+    char* BOOST_PP_CAT(e, __LINE__)[] = expected;\
+    vector<string> BOOST_PP_CAT(v, __LINE__) = split_winmain(input);\
+    check_equal(BOOST_PP_CAT(v, __LINE__), BOOST_PP_CAT(e, __LINE__),\
+                sizeof(BOOST_PP_CAT(e, __LINE__))/sizeof(char*));    
+
+// The following expectations were obtained in Win2000 shell:
+    TEST("1 ", {"1"});
+    TEST("1\"2\" ", {"12"});
+    TEST("1\"2  ", {"12  "});
+    TEST("1\"\\\"2\" ", {"1\"2"});
+    TEST("\"1\" \"2\" ", {"1" C "2"});
+    TEST("1\\\" ", {"1\""});
+    TEST("1\\\\\" ", {"1\\ "});
+    TEST("1\\\\\\\" ", {"1\\\""});
+    TEST("1\\\\\\\\\" ", {"1\\\\ "});
+
+    TEST("1\" 1 ", {"1 1 "});
+    TEST("1\\\" 1 ", {"1\"" C "1"});
+    TEST("1\\1 ", {"1\\1"});
+    TEST("1\\\\1 ", {"1\\\\1"});    
+}
+
+int main(int, char*[])
+{
+    test_winmain();
+    return 0;
+}
+#else
+int main(int, char*[])
+{
+    return 0;
+}
+#endif

libs/program_options/test/winmain.py

@@ -0,0 +1,39 @@
+
+from StringIO import StringIO
+import string
+
+testcases = r"""1 -> 1
+1"2" -> 12
+1"2  -> 12
+1"\"2" -> 1"2
+"1" "2" -> 1, 2
+1\" -> 1"
+1\\" -> 1\  
+1\\\" -> 1\"  
+1\\\\" -> 1\\  
+1" 1 -> 1 1
+1\" 1 -> 1", 1
+1\1 -> 1\1
+1\\1 -> 1\\1
+"""
+
+#testcases = r"""1\\\\" -> 1\\
+#"""
+
+t = StringIO(testcases)
+
+def quote(s):
+    result = s.replace("\\", r"\\")
+    result = result.replace("\"", "\\\"")
+    return '"' + result + '"'
+
+
+for s in t:
+    s = string.strip(s)
+    (value, result) = string.split(s, "->")
+#    print value, result
+    tokens = string.split(result, ",")
+    value = quote(value)
+    tokens = map(string.strip, tokens)
+    tokens = map(quote, tokens)
+    print "TEST(%s, {%s});" % (value, string.join(tokens, ","))