root/trunk/examples/util/config/FunctionTest.d

/*******************************************************************************

    License:    Boost Software License, v. 1.0
                Academic Free License, v. 3.0
                BSD License

    Authors:    Marcin Kuszczak, www.zapytajmnie.com (author's christian site)
                This software is inspired and partially based on Boost C++
                library named 'program_options' and created by Vladimir Prus.

    Version:    0.9.1
    Date:       30-Apr-2008

    History:    0.9.0 (08-Oct-2007) -   initial public version

    Description:
                Function test module

 ******************************************************************************/

import std.stdio;
import std.string;
import std2.conv;

import doost.core.Any;
import doost.util.DUnit;
import doost.util.config.ProgramOptions;        //Always
import doost.util.config.CommandLineStorage;    //Only if backend is necessary
import doost.util.config.ConfigFileStorage;     //Only if backend is necessary
import doost.util.config.EnvironmentStorage;    //Only if backend is necessary
import doost.util.config.DbStorage;             //Only if backend is necessary
import doost.util.config.Formatter;             //Only for non-standard output
                                                //description and for user defined
                                                //formatters

//import doost.util.config.Value;

version(ddbi_v62) {
    import dbi.Database;
    import dbi.Row;
    import dbi.sqlite.SqliteDatabase;
}

//------------------------------------------------------------------------------

class MyVal {
    this(int v) {
        this.v=v;
    }
    int opEquals(MyVal v) {
        assert(v !is null);
        return (v.v == this.v);
    }
    int v;
}

//------------------------------------------------------------------------------
MyVal parseMyValue(string s) {
    int val;
    try {
        val=to!(int)(s);
    } catch (Exception) {
        throw new InvalidOptionValueException(s);
    }
    return new MyVal(val);
}

//------------------------------------------------------------------------------

unittest {
    testSuite.begin("ProgramOptions");
}

//------------------------------------------------------------------------------

unittest { testCase.execute("Opt.Description - regular options", {
    RegularOptions ro;

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("doTheTest,d", "maketest")
        ("doTheCoffee,f", "makecoffee")
        ("doTheTea,a", define!(bool)("tak|ok|1|włÄ
cz"), "maketea")
        ("turnItOn,r", boolSwitch, "makecoffee")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("myVal", define!(MyVal).parser(&parseMyValue), "include paths")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
        ("date", define!(char[])(r"\d\d\d\d-\d?\d-\d?\d"), "date of birth")
        ("regexp[ression]*,g", define!(char[]), "regular expression", new RegExpOption)
        ("number\\d\\d", define!(byte), "following numbers", new RegExpOption)
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("other,o", define!(double), "other parameter")
        //Only alias option
        (",J", define!(char[][]), "import paths")
    ;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Opt.Description - adding groups", {
    RegularOptions ro, ro1, ro2;
    string real_desc, expc_desc;


    ro = new RegularOptions("First group");
    ro.options()
        ("help,h", "produce help message")
        ("compression,c", define!(uint), "compression level")
        ("date", define!(char[]), "start date")
    ;

    ro1 = new RegularOptions("Second group");
    ro1.options()
        ("title,t", define!(char[]), "window title")
        ("process,p", define!(uint), "process number")
    ;

    ro2 = new RegularOptions("All options");
    ro2.add(ro).add(ro1);

    ro2 = new RegularOptions("All options");
    ro2.add(ro, ro1);

    ro2 = new RegularOptions("All options");
    ro2.options()
            (ro)
            (ro1)
    ;

    real_desc = ro2.toString;
    //std.file.write("ro2.txt", cast(void[])real_desc);
    expc_desc ="
        All options

        First group
            help                  produce help message
            compression arg       compression level
            date arg              start date

        Second group
            title arg             window title
            process arg           process number
    ";

    //writefln("\n", real_desc);
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    ro2 = new RegularOptions("All options");
    ro2.options()
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        (ro)
        (ro1);

    real_desc = ro2.toString;
    //std.file.write("ro2.txt", cast(void[])real_desc);
    expc_desc ="
        All options
            firstname arg         firstname
            secondname arg        secondname

        First group
            help                  produce help message
            compression arg       compression level
            date arg              start date

        Second group
            title arg             window title
            process arg           process number
    ";

    //writefln("\n", real_desc);
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Opt.Description - special CL options", {
    auto spc = new CommandLineOptions;
    spc.options()
        ("selfpath", new SelfPath)
        ("selfdir", new SelfDir)
        ("selfname", new SelfName)
        ("firstname=2, secondname=2, nickname=*", new PositionalOption)
    ;

});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Opt.Description - options sanity", {
    RegularOptions ro;
    CommandLineOptions clo;

    assert(checkAssert({
        ro = new RegularOptions;
        ro.options()
            ("title,t", define!(char[]), "window title")
            ("process,t", define!(uint), "process number")
        ;
    }));

    assert(checkAssert({
        ro = new RegularOptions;
        ro.options()
            ("title", define!(char[]), "window title")
            ("title,t", define!(uint), "process number")
        ;
    }));

    assert(checkAssert({
        ro = new RegularOptions;
        ro.options()
            ("title", define!(char[]), "window title")
            ("title,t", define!(uint), "process number")
        ;
    }));

    assert(checkAssert({
        ro = new RegularOptions;
        ro.options()
            (".*", define!(char[]), "all other options")
            (".*", define!(char[]), "other other options")
        ;
    }));

    assert(checkAssert({
        clo = new CommandLineOptions;
        clo.options()
            ("selfpath", new SelfPath)
            ("selfpath", new SelfPath)
        ;
    }));

});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - lists", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    args = ["bin", "--help", "--include", "'a','b','c'"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
    ;

    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.connect;
    assert(("help" in po) !is null);
    assert(checkException!(UnknownOptionException)({"blah" in po; }));

    assert(po["include"].as!(char[][]) == ["a", "b", "c"]);
    po.disconnect;

    args = ["bin", "--include", "a,b,c", "--firstname=Anita , 'Ewa Krystyna', Paulina",
    "--secondname", "'Korwin\\tMikke'", "-n[Aarti, Bono, Bruce]"];
    po.storage!(CommandLineStorage).args(args);

    po.connect;

    trace(po["include"].as!(char[][]));
    assert(po["include"].as!(char[][]) == ["a", "b", "c"]);
    assert(po["firstname"].as!(char[][]) == ["Anita", "Ewa Krystyna", "Paulina"]);
    trace(po["secondname"].as!(char[][]));
    assert(po["secondname"].as!(char[][]) == ["Korwin\tMikke"]);
    trace(po["nickname"].as!(char[][]));
    assert(po["nickname"].as!(char[][]) == ["Aarti", "Bono", "Bruce"]);

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - long/short options", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    args = ["bin", "-rh"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("turnItOn,r", boolSwitch, "makecoffee")
    ;

    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.connect;
    assert(("help" in po) !is null);
    assert(("turnItOn" in po) !is null);
    po.disconnect;

    po.connect;
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - response files", {
    void[] buffer;
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    buffer = cast(void[]) "-r \n--date=1975-07-04 \r\n --firstname=Ala,Ola,Sylwia
    --secondname \n[Atkinson, Bullock]";

    std.file.write("options.rsp", buffer);
    scope(exit) std.file.remove("options.rsp");

    args = ["bin", "@options.rsp"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("turnItOn,r", boolSwitch, "makecoffee")
        ("date", define!(char[])(r"\d\d\d\d-\d?\d-\d?\d"), "date of birth")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
    ;

    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.connect;

    assert(("turnItOn" in po) !is null);
    assert(po["date"].as!(char[]) == "1975-07-04");
    assert(po["firstname"].as!(char[][]) == ["Ala", "Ola", "Sylwia"]);
    assert(po["secondname"].as!(char[][]) == ["Atkinson", "Bullock"]);

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - custom values", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("doTheTest,d", "maketest")
        ("myVal", define!(MyVal).parser(&parseMyValue), "include paths")
    ;

    args = ["bin", "--compression=8", "--myVal=7", "--help"];
    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.connect;

    assert(("compression" in po) !is null);
    assert(("doTheTest" in po) is null);
    assert(po["compression"].as!(int) == 8);
    assert(("title" in po) !is null);
    assert(po["title"].as!(char[]) == "title");
    assert(po["myVal"].as!(MyVal) == new MyVal(7));
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - self path", {
    char[][] args;
    string str1, str2, str3;
    RegularOptions ro;
    CommandLineOptions clo;
    ProgramOptions po;

    version(linux) {
        args = ["/usr/local/bin/potest", "--compression=8"];
        str1 = "/usr/local/bin/potest";
        str2 = "/usr/local/bin";
        str3 = "potest";
    } else
    version(Win32) {
        args = [r"C:\directory\file.exe", "--compression=8"];
        str1 = r"C:\directory\file.exe";
        str2 = r"C:\directory";
        str3 = r"file.exe";
    }

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("compression,c", define!(int), "set compression level")
    ;

    clo = new CommandLineOptions;
    clo.options()
        ("selfpath", new SelfPath)
        ("selfdir", new SelfDir)
        ("selfname", new SelfName)
    ;

    po = (new ProgramOptions).next(
            (new CommandLineStorage(args))
                .options(ro, clo)
         );

    po.connect;
    assert(("selfpath" in po) !is null);
    trace(po["selfpath"].as!(char[]));
    assert(po["selfpath"].as!(char[]) == str1);
    assert(("selfdir" in po) !is null);
    assert(po["selfdir"].as!(char[]) == str2);
    assert(("selfname" in po) !is null);
    assert(po["selfname"].as!(char[]) == str3);
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - synchronization", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("doTheTest,d", "maketest")
    ;

    args = ["bin", "--compression=8"];
    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );
    po.connect;
    assert(po.storage!(CommandLineStorage).syncPolicy == SyncPolicy.Cached);
    assert(po.storage!(CommandLineStorage).defaultSyncPolicy == SyncPolicy.Cached);
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - constraints", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    args = ["bin", "-i/usr/local", "-i/usr/", "-i/bin/", "--compression=9", "--title='Alien'"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("doTheTest,d", "maketest")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("myVal", define!(MyVal).parser(&parseMyValue), "include paths")
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
    ;

    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.connect;

    assert(checkException!(ConstraintViolationException)({obligatoryOptions(po, ["int"]);}));
    assert(checkException!(ConstraintViolationException)({obligatoryOptions(po.storage!(CommandLineStorage), ["int"]);}));
    assert(checkException!(ConstraintViolationException)({conflictingOptions(po.storage!(CommandLineStorage), "compression", "title");}));
    conflictingOptions(po.storage!(CommandLineStorage), "compression", "myVal");
    assert(checkException!(ConstraintViolationException)({dependantOptions(po.storage!(CommandLineStorage), "compression", "string");}));

    po.disconnect;
});}

//------------------------------------------------------------------------------

//TODO: additional test case: connect - disconnect - connect again - disconnect

unittest { testCase.execute("CL Storage - input options composing", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("doTheTest,d", "maketest")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
    ;

    args = ["bin", "-i/usr/local", "-i/usr/", "-i/bin/", "--int=265"];

    po = (new ProgramOptions).next(
            new CommandLineStorage(args, ro)
         );

    po.storage!(CommandLineStorage).args(args);
    po.connect;

    // compression is not passed as arguments, so below exception should be thrown
    assert(checkException!(OptionHasNoValueException)({po["compression"];}));
    assert(("compression" in po.storage!(CommandLineStorage)) is null);
    assert(checkException!(OptionHasNoValueException)({po.storage!(CommandLineStorage)["compression"];}));
    trace(po["include"].as!(char[][]));
    assert(po["include"].as!(char[][]) == ["/usr/local", "/usr/", "/bin/"]);
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - positional options", {
    char[][] args;
    RegularOptions ro;
    CommandLineOptions clo;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("doTheTest,d", "maketest")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
    ;

    clo = new CommandLineOptions;
    clo.options()
        ("firstname=2, secondname=2, nickname=*", new PositionalOption)
    ;

    args = ["bin", "Ala", "Ola", "Kowalska", "Nowak", "Aarti_pl"];
    po = (new ProgramOptions).next(
            (new CommandLineStorage(args))
                .options(ro, clo)
         );

    po.connect;
    assert(po["firstname"].as!(char[][]) == ["Ala", "Ola"]);
    assert(po["secondname"].as!(char[][]) == ["Kowalska", "Nowak"]);
    assert(po["nickname"].as!(char[][]) == ["Aarti_pl"]);
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - regular expression options", {
    char[][] args;
    RegularOptions ro;
    CommandLineOptions clo;
    ProgramOptions po;

    args = ["bin", "--compression", "8", "--string", "'D language'", "--regexpression=regexpstring", "--date=1975-7-4"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("doTheTest,d", "maketest")
        ("doTheCoffee,f", "makecoffee")
        ("doTheTea,a", define!(bool)("tak|ok|1|włÄ
cz|nie|0|wyłÄ
cz"), "maketea")
        ("turnItOn,r", boolSwitch, "makecoffee")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
        ("date", define!(char[])(r"\d\d\d\d-\d?\d-\d?\d"), "date of birth")
        ("regexp[ression]*,g", define!(char[]), "regular expression", new RegExpOption)
        ("number\\d\\d", define!(byte), "following numbers", new RegExpOption)
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("other,o", define!(double), "other parameter")
        //Only alias name
        (",J", define!(char[][]), "import paths")
    ;

    clo = new CommandLineOptions;
    clo.options()
        ("firstname=2, secondname=2, nickname=*", new PositionalOption)
    ;

    po = (new ProgramOptions).next(
            (new CommandLineStorage(args))
                .options(ro, clo)
         );

    po.connect;

    assert(("regexpression" in po) !is null);
    assert(po["regexpression"].as!(char[]) == "regexpstring");
    assert(po["compression"].as!(int) == 8);
    assert(po["date"].as!(char[]) == "1975-7-4");
    trace(po["string"].as!(char[]));
    assert(po["string"].as!(char[]) == "D language");

    po.disconnect;

    args = ["bin", "--regexp=regexpstring", "--number00=34", "--number01=35",
            "--date=1975-07-04", "-c5", "-ttitle", "-df", "--doTheTea=włÄ
cz"];
    po.storage!(CommandLineStorage).args(args);

    po.connect;

    assert(("date" in po) !is null);
    assert(po["date"].as!(char[]) == "1975-07-04");
    assert(("regexp" in po) !is null);
    assert(po["regexp"].as!(char[]) == "regexpstring");
    assert(("number00" in po) !is null);
    assert(po["number00"].as!(byte) == 34);
    assert(("number01" in po) !is null);
    assert(po["number01"].as!(byte) == 35);
    assert(("compression" in po) !is null);
    assert(po["compression"].as!(int) == 5);
    assert(("title" in po) !is null);
    assert(po["title"].as!(char[]) == "title");
    assert(("doTheTest" in po) !is null);
    assert(("doTheCoffee" in po) !is null);
    assert(("doTheTea" in po) !is null);
    assert(po["doTheTea"].as!(bool) == true);
    assert(checkException!(UnknownOptionException)({"blah" in po; }));

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("CL Storage - option styles", {
    char[][] args;
    RegularOptions ro;
    ProgramOptions po;

    //guessing, caseinsensitive
    args = ["bin", "--turnI", "--oth=0.577215664901532", "--dothetea=ok",
    "--dothecoffee"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("doTheTest,d", "maketest")
        ("doTheCoffee,f", "makecoffee")
        ("doTheTea,a", define!(bool)("tak|ok|1|włÄ
cz"), "maketea")
        ("turnItOn,r", boolSwitch, "makecoffee")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
        ("date", define!(char[])(r"\d\d\d\d-\d?\d-\d?\d"), "date of birth")
        ("regexp[ression]*,g", define!(char[]), "regular expression", new RegExpOption)
        ("number\\d\\d", define!(byte), "following numbers", new RegExpOption)
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("other,o", define!(double), "other parameter")
        //Only alias name
        (",J", define!(char[][]), "import paths")
    ;

    po = (new ProgramOptions).next(
            (new CommandLineStorage(args, ro))
                .style(Style.DefaultStyle | Style.AllowLongInsensitive)
         );

    po.connect;
    assert(("turnItOn" in po) !is null);
    assert(po["turnItOn"].as!(bool) == true);
    assert(po["doTheTea"].as!(bool) == true);
    assert(("doTheCoffee" in po) !is null);
    assert(("other" in po) !is null);
    assert(po["other"].as!(double) == 0.577215664901532);
    po.disconnect;

    //long disguised, guessing, lack of first is self
    args = ["-compression=8", "-tit=1984"];

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("doTheTest,d", "maketest")
        ("doTheCoffee,f", "makecoffee")
        ("doTheTea,a", define!(bool)("tak|ok|1|włÄ
cz"), "maketea")
        ("turnItOn,r", boolSwitch, "makecoffee")
        ("compression,c", define!(int), "set compression level")
        ("title,t", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing.defaultValue(["default1"[], "default2"]), "include paths")
        ("firstname", define!(char[][]).composing, "firstname")
        ("secondname", define!(char[][]).composing, "secondname")
        ("nickname,n", define!(char[][]).composing, "nickname")
        ("date", define!(char[])(r"\d\d\d\d-\d?\d-\d?\d"), "date of birth")
        ("regexp[ression]*,g", define!(char[]), "regular expression", new RegExpOption)
        ("number\\d\\d", define!(byte), "following numbers", new RegExpOption)
        ("int,p", define!(char[])(r"\d\d\d"), new RegExpOption)
        ("string,s", define!(char[]), "text parameter")
        ("other,o", define!(double), "other parameter")
        //Only alias name
        (",J", define!(char[][]), "import paths")
    ;

    po =    (new ProgramOptions)
                .next(
            (new CommandLineStorage(args))
                .options(ro)
                .style(Style.AllowLong | Style.AllowLongAdjacent | Style.AllowLongDisguise
                    | Style.AllowLongGuessing)
            );

    po.connect;

    assert(po["compression"].as!(int) == 8);
    assert(po["title"].as!(char[]) == "1984");

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Config file", {
    void[] buffer;
    string real_desc, expc_desc;
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("File storage");
    ro.options()
        ("compression", define!(int), "set compression level")
        ("author", define!(char[]).defaultValue("drX"), "name of author")
        ("include,i", define!(char[][]).composing, "include paths")
        ("myname", define!(char[]), "name")
        ("database.user", define!(char[]), "Database User")
        ("database.password", define!(char[]), "Database Password")
        ("database.ip", define!(char[])(r"[0|1|2]?\d?\d\.[0|1|2]?\d?\d\.[0|1|2]?\d?\d\.[0|1|2]?\d?\d"), "Database IP")
        ("interaction.help", "activate help")
        ("interaction.tips", "activate tips")
        ("interaction.balloons", "activate balloons")
    ;

    buffer = cast(void[])
"compression=6 # Kompresja pliku
author=Szklarski # Autor ksiÄ
ÅŒki
include=/usr/local/import/

[interaction]
balloons # Activate ballons
";

    std.file.write("test01.cfg", buffer);
    scope(exit) std.file.remove("test01.cfg");

    po = (new ProgramOptions)
            .next(
         (new ConfigFileStorage("test01.cfg"))
            .options(ro)
         );

    po.connect;

    assert(po["compression"].as!(int) == 6);
    po["compression"] = any!(int)(18);
    po["database.ip"]= any!(char[])("127.0.0.1");
    po["database.user"]= any!(char[])("marcin");
    po["database.password"]= any!(char[])("******");
    assert(po["compression"].as!(int) == 18);
    assert(po["database.ip"].as!(char[]) == "127.0.0.1"[]);

    po.synchronize;
    po.syncPolicy(SyncPolicy.Direct);

    assert(po["compression"].as!(int) == 18);
    assert(po["database.ip"].as!(char[]) == "127.0.0.1"[]);
    assert(po["database.user"].as!(char[]) == "marcin"[]);
    assert(po["database.password"].as!(char[]) == "******"[]);
    assert("interaction.balloons" in po);
    assert(po["author"].as!(char[]) == "Szklarski");
    po["author"] = any!(char[])("Niziurski");
    assert(po["author"].as!(char[]) == "Niziurski");

    po.syncPolicy(SyncPolicy.Cached);

    assert(po["include"].as!(char[][]) == ["/usr/local/import/"]);
    po.storage!(ConfigFileStorage)()["include"] = any!(char[][])(["/usr/local/bin/", "/bin/", "/usr/bin/"]);

    po.synchronize;

    assert(po["include"].as!(char[][]) == ["/usr/local/bin/", "/bin/", "/usr/bin/"]);
    po["myname"] = any!(char[])("Aarti_pl");

    po.synchronize;
    assert(po["myname"].as!(char[]) == "Aarti_pl");

    real_desc = cast(char[])std.file.read("test01.cfg");
    expc_desc =
"compression = 18 # Kompresja pliku
author = \"Niziurski\" # Autor ksiÄ
ÅŒki
include = \"/usr/local/bin/\", \"/bin/\", \"/usr/bin/\"
myname = \"Aarti_pl\"

[interaction]
balloons                                  # Activate ballons

[database]
ip = \"127.0.0.1\"
user = \"marcin\"
password = \"******\"
";

    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    po.storage!(ConfigFileStorage).remove("author");
    po.synchronize;

    real_desc = cast(char[])std.file.read("test01.cfg");
    expc_desc =
"compression = 18 # Kompresja pliku
include = \"/usr/local/bin/\", \"/bin/\", \"/usr/bin/\"
myname = \"Aarti_pl\"

[interaction]
balloons                       # Activate ballons

[database]
ip = \"127.0.0.1\"
user = \"marcin\"
password = \"******\"
";

    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    po.remove("database.password");
    po.remove("database.ip");
    po.synchronize;

    real_desc = cast(char[])std.file.read("test01.cfg");
    expc_desc ="
        compression = 18 # Kompresja pliku
        include = \"/usr/local/bin/\", \"/bin/\", \"/usr/bin/\"
        myname = \"Aarti_pl\"
        [interaction]
        balloons                       # Activate ballons
        [database]
        user = \"marcin\"
    ";

    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    po.disconnect;

    po.connect;

    assert(po["compression"].as!(int) == 18);
    assert(po["myname"].as!(char[]) == "Aarti_pl");
    po.disconnect;

    buffer = cast(void[])
"compression=6 # Kompresja pliku
author=Szklarski # Autor ksiÄ
ÅŒki
include=/usr/local/import/
blah=5
";

    std.file.write("test02.cfg", buffer);
    scope(exit) std.file.remove("test02.cfg");

    po = (new ProgramOptions)
            .next(
         (new ConfigFileStorage("test02.cfg"))
            .options(ro)
         );

    assert(checkException!(UnknownOptionException)({po.connect;}));

    buffer = cast(void[])
"compression=6 # Kompresja pliku
author=\"Szklarski\" # Autor ksiÄ
ÅŒki
include=/usr/local/import/
";

    std.file.write("test03.cfg", buffer);
    scope(exit) std.file.remove("test03.cfg");

    po = (new ProgramOptions)
            .next(
         (new ConfigFileStorage("test03.cfg"))
            .options(ro)
            .syncPolicy(SyncPolicy.Direct)
         );

    po.connect;

    po.storage!(ConfigFileStorage).remove("compression");
    po.storage!(ConfigFileStorage)()["author"] = any!(char[])("Nienacki");
    po["database.ip"] = any!(char[])("223.14.80.34");
    po["database.password"] = any!(char[])("***");
    po["database.user"] = any!(char[])("Magda");
    po["interaction.help"] = any!()();
    po["interaction.tips"] = any!()();

    real_desc = cast(char[])std.file.read("test03.cfg");
    expc_desc ="
        author = \"Nienacki\" # Autor ksiÄ
ÅŒki
        include = /usr/local/import/

        [database]
        ip = \"223.14.80.34\"
        password = \"***\"
        user = \"Magda\"

        [interaction]
        help
        tips
    ";

    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    po.disconnect;

    real_desc = cast(char[])std.file.read("test03.cfg");
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Env variables - simple", {
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("Environment options");
    ro.options()
        ("po_include", define!(char[][]).composing, "include paths")
        ("po_compiler", define!(char[]).defaultValue("dmd"), "default compiler")
        ("po_linker", define!(char[]).defaultValue("link"), "default linker")
        ("po_threads", define!(uint).defaultValue(3), "number of compilation threads")
    ;

    po = (new ProgramOptions)
            .next(
         (new EnvironmentStorage)
            .options(ro)
         );

    po.connect;

    assert(!("po_include" in po));
    assert("po_compiler" in po);
    assert(po["po_compiler"].as!(char[]) == "dmd");
    assert("po_linker" in po);
    assert(po["po_linker"].as!(char[]) == "link");
    assert("po_threads" in po);
    assert(po["po_threads"].as!(uint) == 3);

    po["po_compiler"] = any!(char[])("gdb");
    assert(po["po_compiler"].as!(char[]) == "gdb");
    po["po_linker"] = any!(char[])("gcc");
    assert(po["po_linker"].as!(char[]) == "gcc");

    po.disconnect;

    po.connect;

    assert(po["po_compiler"].as!(char[]) == "gdb");
    assert(po["po_linker"].as!(char[]) == "gcc");

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Stack", {
    int counter, compression;
    string real_desc, expc_desc;
    string[] args, args1;
    void[] buffer, buffer1;
    RegularOptions ro, ro1, fil, fil1;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("help,h", "produce help message")
        ("compression", define!(int).defaultValue(2), "set compression level")
        ("title", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing, "include paths")
    ;

    ro1 = new RegularOptions("Command line");
    ro1.options()
        ("help,h", "produce help message")
        ("title", define!(char[]).defaultValue("title"), "set title of window")
        ("include,i", define!(char[][]).composing, "include paths")
    ;

    fil = new RegularOptions("File storage");
    fil.options()
        ("compression", define!(int), "set compression level")
        ("author", define!(char[]).defaultValue("drX"), "name of author")
        ("include,i", define!(char[][]).composing, "include paths")
    ;

    fil1 = new RegularOptions("File storage 1");
    fil1.options()
        ("comment", define!(char[]).defaultValue("my comment"), "comment to last news")
        ("list,l", "list all paths")
        ("title", define!(char[]).defaultValue("title"), "title of window")
    ;


    buffer = cast(void[])
"compression=6
author=Szklarski
include=/usr/local/import/
";

    std.file.write("test04.cfg", buffer);
    scope(exit) std.file.remove("test04.cfg");

    buffer1 = cast(void[])
"title=mytitle\n";

    std.file.write("test05.cfg", buffer1);
    scope(exit) std.file.remove("test05.cfg");

    args = ["bin", "-i/usr/local", "-i/usr/", "-i/bin/", "-h"];
    args1 = ["bin", "-i/usr/local", "-i/usr/", "-i/bin/"];

    po = (new ProgramOptions)
            .next(
         (new CommandLineStorage(args))
            .options(ro)
            .next(
         (new ConfigFileStorage("test04.cfg"))
            .options(fil)
            .next(
         (new ConfigFileStorage("test05.cfg"))
            .options(fil1)
            .formatter(new BasicFormatter)
         )));

    counter = 0;
    void call(Event e) {
        //writefln("Called: ", e.name, " with value: ", e.value.value.type);
        counter++;
    }

    po.callback("compression", [&call, delegate void(Event e) {compression = e.value.as!(int);}]);
    po.notifyPolicy(NotifyPolicy.Default | NotifyPolicy.OnSelfModify);

    po.connect;
    assert(("help" in po) !is null);
    assert(("compression" in po) !is null);
    assert(po["compression"].as!(int) == 6);
    assert(po["author"].as!(char[]) == "Szklarski");

    assert(po.composedOptions("include").as!(char[][]) == ["/usr/local", "/usr/", "/bin/", "/usr/local/import/"]);
    assert(po.composedOptions("title").as!(char[][]) == ["title", "mytitle"]);

    po.storage!(CommandLineStorage)()["compression"] = any!(int)(2);
    assert(po.storage!(CommandLineStorage)["compression"].as!(int) == 2);
    assert(po["compression"].as!(int) == 2);
    po["compression"]=any!(int)(15);
    assert(po["compression"].as!(int) == 15);
    assert(po.storage!(CommandLineStorage)["compression"].as!(int) == 15);
    assert(po.storage!(ConfigFileStorage)["compression"].as!(int) == 15);
    po["help"]=any!()();
    assert(po["help"] !is null);

    real_desc = po.storage!(CommandLineStorage).toString;
    expc_desc ="
        Command line
        -h [--help]              produce help message
        --compression arg (=2)   set compression level
        --title arg (=\"title\") set title of window
        -i [--include] arg       include paths
    ";

    //writefln(real_desc);
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    real_desc = po.storage!(ConfigFileStorage)().storage!(ConfigFileStorage)().toString;
    expc_desc ="
        File storage 1
        comment arg (=\"my comment\") comment to last news
        list                      list all paths
        title arg (=\"title\")        title of window
    ";
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    real_desc = po.toString;
    expc_desc ="
        Command line
        -h [--help]            produce help message
        --compression arg (=2) set compression level
        --title arg (=\"title\")   set title of window
        -i [--include] arg     include paths

        File storage 1
        comment arg (=\"my comment\") comment to last news
        list                      list all paths
        title arg (=\"title\")        title of window
    ";

    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));
    //Two hits: po["compression"]=any!(int)(15);
    //First hit is for not persistant CommandLineStorage and second one for
    //persistant ConfigFileStorage
    //po.storage!(CommandLineStorage)()["compression"]=any!(int)(2);
    //Above is not counted as assigning replaces default value, which is threated
    //as self insert not self modification.

    assert(counter == 2);
    assert(compression == 15);

    assert(po.storage!(ConfigFileStorage)().storage!(ConfigFileStorage)()["title"].as!(char[])=="mytitle");

    po.disconnect;

    po = (new ProgramOptions)
            .next(
         (new CommandLineStorage(args1, ro1))
         );

    po.connect;

    assert(checkException!(UnknownOptionException)({po["compression"]=any!(int)(15);}));
    assert(("help" in po) is null);

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Stack - options 'Very Easy Init'", {
    //Though, you can sometimes get lost in parenthesises ;-)

    string[] args;
    void[] buffer;
    ProgramOptions po;

    args = ["bin", "-rh"];

    buffer = cast(void[]) "compression=6\n"
                          "author=Szklarski\n"
                          "include=/usr/local/import/\n";

    std.file.write("test10.cfg", buffer);
    scope(exit) std.file.remove("test10.cfg");

    po =    (new ProgramOptions)
                .caption("pi.exe - program to calculate PI with any precision \n"
                         "in less than 1 second. (c)2007 Aarti_pl"
                        )
                .next(
            (new CommandLineStorage(args))
                .caption("Command line options:\n"
                         "usage: pi.exe [options] file1, file2 ...."
                        )
                .options()
                    ("help,h", "produce help message")
                    ("turnItOn,r", boolSwitch, "makecoffee")
                    ("selfdir", new SelfDir)
                    ("selfname", new SelfName)
                    ()
                .next(
            (new ConfigFileStorage("test10.cfg"))
                .caption("Config file options:\n"
                         "usage: change contents of pi.ini file in program binary directory"
                        )
                .options()
                    ("compression", define!(int), "set compression level")
                    ("author", define!(char[]).defaultValue("drX"), "name of author")
                    ("include,i", define!(char[][]).composing, "include paths")
                    ()
                .formatter(new BasicFormatter)
            ));

    po.connect;
    assert(("help" in po) !is null);
    assert(("turnItOn" in po) !is null);
    assert(po["compression"].as!(int) == 6);
    po.disconnect;

    po.connect;
    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Stack - downStackSync", {
    void[] buffer, buffer1;
    string real_desc, expc_desc;
    string[] args;
    RegularOptions ro, fil, fil1;
    ProgramOptions po;


    ro = new RegularOptions("Command line");
    ro.options()
        ("compression", define!(int).defaultValue(2), "set compression level")
    ;

    fil = new RegularOptions("File storage");
    fil.options()
        ("compression", define!(int), "set compression level")
    ;

    fil1 = new RegularOptions("File storage 1");
    fil1.options()
        ("comment", define!(char[]).defaultValue("my comment"), "comment to last news")
    ;


    buffer = cast(void[])
"compression=6\n";

    std.file.write("test06.cfg", buffer);
    scope(exit) std.file.remove("test06.cfg");

    buffer1 = cast(void[]) "";
    std.file.write("test07.cfg", buffer1);
    scope(exit) std.file.remove("test07.cfg");

    args = ["bin", "--compression=128"];

    po = (new ProgramOptions)
            .next(
         (new CommandLineStorage(args))
            .options(ro)
            .next(
         (new ConfigFileStorage("test06.cfg"))
            .options(fil)
            .next(
         (new ConfigFileStorage("test07.cfg"))
            .options(fil1)
         )));

    po.connect;

    po.downStackSync("compression");
    po.synchronize;

    real_desc = cast(char[])std.file.read("test06.cfg");
    expc_desc ="compression = 128";
    assert(removechars(real_desc, " \t\n\r") == removechars(expc_desc, " \t\n\r"));

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Stack - defined/assigned/collected", {
    void[] buffer;
    string[] args;
    string[] opts1, opts2, opts3;
    RegularOptions ro, fil;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression", define!(int).defaultValue(2), "set compression level")
        ("name", define!(char[]), "name of zip")
        ("help,h", "help for options")
        (r"chanel\d", define!(int), "chanel number", new RegExpOption)
    ;

    fil = new RegularOptions("Properties file");
    fil.options()
        ("compression", define!(int), "set compression level")
        ("package", define!(char[]), "package name")
        (r"port\d\d\d,h", boolSwitch, "port to activate", new RegExpOption)
    ;

    buffer = cast(void[])
"compression=6
port128
port024
port228
";

    std.file.write("test08.cfg", buffer);
    scope(exit) std.file.remove("test08.cfg");

    args = ["bin", "--compression=8", "--help"];

    po = (new ProgramOptions)
            .next(
         (new CommandLineStorage(args))
            .options(ro)
            .next(
         (new ConfigFileStorage("test08.cfg"))
            .options(fil)
         ));

    po.connect;

    opts1=po.storage!(CommandLineStorage).definedOptions;
    opts2=po.storage!(CommandLineStorage).assignedOptions;
    opts3=po.storage!(CommandLineStorage).collectedOptions;
    //std.file.write("result1.txt", std.string.format(opts1));
    //std.file.write("result2.txt", std.string.format(opts2));
    //std.file.write("result3.txt", std.string.format(opts3));
    assert(opts1==["compression","name","help", r"chanel\d"]);
    assert(opts2==["help","compression"]);
    assert(opts3==null);

    opts1=po.definedOptions;
    opts2=po.assignedOptions;
    opts3=po.collectedOptions;
    //std.file.write("result1.txt", std.string.format(opts1));
    //std.file.write("result2.txt", std.string.format(opts2));
    //std.file.write("result3.txt", std.string.format(opts3));
    assert(opts1==[r"chanel\d",r"port\d\d\d","help","compression","package","name"]);
    assert(opts2==["port128","help","port228","compression","port024"]);
    assert(opts3==["port128","port228","port024"]);

    po.disconnect;
});}

//------------------------------------------------------------------------------

unittest { testCase.execute("Stack - no args for CL", {
    void[] buffer;
    string[] args;
    RegularOptions ro, fil;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression", define!(int).defaultValue(2), "set compression level")
        ("name", define!(char[]), "name of zip")
        ("help,h", "help for options")
        (r"chanel\d", define!(int), "chanel number", new RegExpOption)
    ;

    fil = new RegularOptions("Properties file");
    fil.options()
        ("compression", define!(int), "set compression level")
        ("package", define!(char[]), "package name")
        (r"port\d\d\d,h", boolSwitch, "port to activate", new RegExpOption)
    ;

    buffer = cast(void[])
"compression=6
port128
port024
port228
";
    std.file.write("test09.cfg", buffer);
    scope(exit) std.file.remove("test09.cfg");

    args = ["bin"];

    po = (new ProgramOptions)
            .next(
         (new CommandLineStorage(args))
            .options(ro)
            .next(
         (new ConfigFileStorage("test09.cfg"))
            .options(fil)
         ));

    po.connect;

    assert(("help" in po) is null);
    assert(("name" in po) is null);
    assert(("compression" in po) !is null);
    assert(po["compression"].as!(int) == 6);

    po.disconnect;
});}

//------------------------------------------------------------------------------
//NOTE: to allow following test you should have installed and compilled
//DDBI revision 62 and add '-version=ddbi_v62' to compiler command line
version(ddbi_v62) {
unittest { testCase.execute("DbStorage - basic", {
    RegularOptions ro;
    ProgramOptions po;

    ro = new RegularOptions("Command line");
    ro.options()
        ("compression", define!(int).defaultValue(2), "set compression level")
        ("name", define!(char[]), "name of zip")
        ("help,h", "help for options")
        (r"chanel\d", define!(int), "chanel number", new RegExpOption)
    ;

    Database db = new SqliteDatabase("test.db");
    scope(exit) db.close;

    po = (new ProgramOptions).next(
            (new DbStorage(db, "TB_PARAMS", ro))
         );

    po.connect;

    assert(("help" in po) is null);

    po["compression"] = any!(int)(52);

    assert(("compression" in po) !is null);
    assert(po["compression"].as!(int) == 52);

    po["name"] = any!(char[])("Aarti_pl");
    assert(po["name"].as!(char[]) == "Aarti_pl");

    po["name"] = any!(char[])("Wacek");
    assert(po["name"].as!(char[]) == "Wacek");

    //NOTE: for unknown reasons when using execute() in DbStorage below test fails
    foreach(o; po.assignedOptions)
        po.remove(o);

    assert(po.assignedOptions == null);

    po.disconnect;
});}
}

//------------------------------------------------------------------------------

unittest {
    testSuite.finish;
}

//------------------------------------------------------------------------------

/*******************************************************************************
    Program entry point
 ******************************************************************************/
int main(char[][] args) {
    try {
        char sep = ';';
        version(linux) sep=':';

        auto po =   (new ProgramOptions)
                        .next(
                    (new CommandLineStorage(args))
                        .caption("Command line options")
                        .options()
                            ("help,h", "produce help message")
                            ("compression", define!(int), "set compression level")
                            ("list", define!(int[][]), "complicated list")
                            ("sync", "stores given from command line options in persistent backend")
                            ()
                        .next(
                    (new EnvironmentStorage)
                        .options()
                            ("Path,PATH", define!(char[][]).separator(sep), "paths defined in system")
                            ()
                        .next(
                    (new ConfigFileStorage("file1.cfg"))
                        .options()
                            ("optimization", define!(int), "level")
                            ("include-path", define!(char[][]), "include paths")
                            ("compression", define!(int), "set compression level")
                            ()
                        .next(
                    (new ConfigFileStorage("file2.cfg"))
                        .options()
                            ("name", define!(char[]), "name of game")
                            ("pi", define!(double), "value of eternity")
                            ()
                    ))));

        po.connect();

        if ("help" in po) {
            writefln(po);
            return 0;
        }

        if ("compression" in po) {
            writefln("Compression level was set to ", po["compression"]);
        } else {
            writefln("Compression level was not set.");
        }

        if ("optimization" in po) {
            writefln("Optimization set to: ", po["optimization"]);
        }

        if ("pi" in po) {
            writefln("Pi set to: ", po["pi"]);
        }

        if ("name" in po) {
            writefln("Name set to: ", po["name"]);
        }

        if ("PATH" in po) {
            writefln("\n\nThere are following directories in your system path: \n");

            foreach(p; po["Path"].as!(char[][])) {
                writefln(p);
            }
        }

        if ("sync" in po) {
            foreach(o; po.storage!(CommandLineStorage).assignedOptions)
                if (o!="sync") po.downStackSync(o);
        }

        po.disconnect;

    }
    catch(ProgramOptionsException e) {
        writefln("Exception: ", e);
        return 1;
    }

    return 0;
}