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