src/test/stdtest/getopts.rs

use std;
import std::vec;
import std::option;
import opt = std::getopts;

tag fail_type {
    argument_missing;
    unrecognized_option;
    option_missing;
    option_duplicated;
    unexpected_argument;
}

fn check_fail_type(opt::fail_ f, fail_type ft) {
    alt (f) {
        case (opt::argument_missing(_)) { assert (ft == argument_missing); }
        case (opt::unrecognized_option(_)) {
            assert (ft == unrecognized_option);
        }
        case (opt::option_missing(_)) { assert (ft == option_missing); }
        case (opt::option_duplicated(_)) { assert (ft == option_duplicated); }
        case (opt::unexpected_argument(_)) {
            assert (ft == unexpected_argument);
        }
        case (_) { fail; }
    }
}


// Tests for reqopt
#[test]
fn test_reqopt_long() {
    auto args = ["--test=20"];
    auto opts = [opt::reqopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "test"));
            assert (opt::opt_str(m, "test") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_long_missing() {
    auto args = ["blah"];
    auto opts = [opt::reqopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_long_no_arg() {
    auto args = ["--test"];
    auto opts = [opt::reqopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_long_multi() {
    auto args = ["--test=20", "--test=30"];
    auto opts = [opt::reqopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_short() {
    auto args = ["-t", "20"];
    auto opts = [opt::reqopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "t"));
            assert (opt::opt_str(m, "t") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_short_missing() {
    auto args = ["blah"];
    auto opts = [opt::reqopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_short_no_arg() {
    auto args = ["-t"];
    auto opts = [opt::reqopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_reqopt_short_multi() {
    auto args = ["-t", "20", "-t", "30"];
    auto opts = [opt::reqopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}


// Tests for optopt
#[test]
fn test_optopt_long() {
    auto args = ["--test=20"];
    auto opts = [opt::optopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "test"));
            assert (opt::opt_str(m, "test") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_long_missing() {
    auto args = ["blah"];
    auto opts = [opt::optopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "test")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_long_no_arg() {
    auto args = ["--test"];
    auto opts = [opt::optopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_long_multi() {
    auto args = ["--test=20", "--test=30"];
    auto opts = [opt::optopt("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_short() {
    auto args = ["-t", "20"];
    auto opts = [opt::optopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "t"));
            assert (opt::opt_str(m, "t") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_short_missing() {
    auto args = ["blah"];
    auto opts = [opt::optopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "t")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_short_no_arg() {
    auto args = ["-t"];
    auto opts = [opt::optopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_optopt_short_multi() {
    auto args = ["-t", "20", "-t", "30"];
    auto opts = [opt::optopt("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}


// Tests for optflag
#[test]
fn test_optflag_long() {
    auto args = ["--test"];
    auto opts = [opt::optflag("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (opt::opt_present(m, "test")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_long_missing() {
    auto args = ["blah"];
    auto opts = [opt::optflag("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "test")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_long_arg() {
    auto args = ["--test=20"];
    auto opts = [opt::optflag("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) {
            log_err opt::fail_str(f);
            check_fail_type(f, unexpected_argument);
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_long_multi() {
    auto args = ["--test", "--test"];
    auto opts = [opt::optflag("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_short() {
    auto args = ["-t"];
    auto opts = [opt::optflag("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (opt::opt_present(m, "t")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_short_missing() {
    auto args = ["blah"];
    auto opts = [opt::optflag("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "t")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_short_arg() {
    auto args = ["-t", "20"];
    auto opts = [opt::optflag("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            // The next variable after the flag is just a free argument

            assert (m.free.(0) == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optflag_short_multi() {
    auto args = ["-t", "-t"];
    auto opts = [opt::optflag("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, option_duplicated); }
        case (_) { fail; }
    }
}


// Tests for optmulti
#[test]
fn test_optmulti_long() {
    auto args = ["--test=20"];
    auto opts = [opt::optmulti("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "test"));
            assert (opt::opt_str(m, "test") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_long_missing() {
    auto args = ["blah"];
    auto opts = [opt::optmulti("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "test")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_long_no_arg() {
    auto args = ["--test"];
    auto opts = [opt::optmulti("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_long_multi() {
    auto args = ["--test=20", "--test=30"];
    auto opts = [opt::optmulti("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "test"));
            assert (opt::opt_str(m, "test") == "20");
            assert (opt::opt_strs(m, "test").(0) == "20");
            assert (opt::opt_strs(m, "test").(1) == "30");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_short() {
    auto args = ["-t", "20"];
    auto opts = [opt::optmulti("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "t"));
            assert (opt::opt_str(m, "t") == "20");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_short_missing() {
    auto args = ["blah"];
    auto opts = [opt::optmulti("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) { assert (!opt::opt_present(m, "t")); }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_short_no_arg() {
    auto args = ["-t"];
    auto opts = [opt::optmulti("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, argument_missing); }
        case (_) { fail; }
    }
}

#[test]
fn test_optmulti_short_multi() {
    auto args = ["-t", "20", "-t", "30"];
    auto opts = [opt::optmulti("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (opt::opt_present(m, "t"));
            assert (opt::opt_str(m, "t") == "20");
            assert (opt::opt_strs(m, "t").(0) == "20");
            assert (opt::opt_strs(m, "t").(1) == "30");
        }
        case (_) { fail; }
    }
}

#[test]
fn test_unrecognized_option_long() {
    auto args = ["--untest"];
    auto opts = [opt::optmulti("t")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, unrecognized_option); }
        case (_) { fail; }
    }
}

#[test]
fn test_unrecognized_option_short() {
    auto args = ["-t"];
    auto opts = [opt::optmulti("test")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::failure(?f)) { check_fail_type(f, unrecognized_option); }
        case (_) { fail; }
    }
}

#[test]
fn test_combined() {
    auto args =
        ["prog", "free1", "-s", "20", "free2", "--flag", "--long=30", "-f",
         "-m", "40", "-m", "50"];
    auto opts =
        [opt::optopt("s"), opt::optflag("flag"), opt::reqopt("long"),
         opt::optflag("f"), opt::optmulti("m"), opt::optopt("notpresent")];
    auto rs = opt::getopts(args, opts);
    alt (rs) {
        case (opt::success(?m)) {
            assert (m.free.(0) == "prog");
            assert (m.free.(1) == "free1");
            assert (opt::opt_str(m, "s") == "20");
            assert (m.free.(2) == "free2");
            assert (opt::opt_present(m, "flag"));
            assert (opt::opt_str(m, "long") == "30");
            assert (opt::opt_present(m, "f"));
            assert (opt::opt_strs(m, "m").(0) == "40");
            assert (opt::opt_strs(m, "m").(1) == "50");
            assert (!opt::opt_present(m, "notpresent"));
        }
        case (_) { fail; }
    }
}