#[doc(hidden)];

// Support code for rustc's built in test runner generator. Currently,
// none of this is meant for users. It is intended to support the
// simplest interface possible for representing and running tests
// while providing a base that other test frameworks may build off of.

import either::either;
import result::{ok, err};
import io::writer_util;
import libc::size_t;
import task::task_builder;

export test_name;
export test_fn;
export test_desc;
export test_main;
export test_result;
export test_opts;
export tr_ok;
export tr_failed;
export tr_ignored;
export run_tests_console;

#[abi = "cdecl"]
extern mod rustrt {
    fn sched_threads() -> libc::size_t;
}

// The name of a test. By convention this follows the rules for rust
// paths; i.e. it should be a series of identifiers seperated by double
// colons. This way if some test runner wants to arrange the tests
// hierarchically it may.
type test_name = ~str;

// A function that runs a test. If the function returns successfully,
// the test succeeds; if the function fails then the test fails. We
// may need to come up with a more clever definition of test in order
// to support isolation of tests into tasks.
type test_fn = fn~();

// The definition of a single test. A test runner will run a list of
// these.
type test_desc = {
    name: test_name,
    fn: test_fn,
    ignore: bool,
    should_fail: bool
};

// The default console test runner. It accepts the command line
// arguments and a vector of test_descs (generated at compile time).
fn test_main(args: ~[~str], tests: ~[test_desc]) {
    let opts =
        match parse_opts(args) {
          either::left(o) => o,
          either::right(m) => fail m
        };
    if !run_tests_console(opts, tests) { fail ~"Some tests failed"; }
}

type test_opts = {filter: option<~str>, run_ignored: bool,
                  logfile: option<~str>};

type opt_res = either<test_opts, ~str>;

// Parses command line arguments into test options
fn parse_opts(args: ~[~str]) -> opt_res {
    let args_ = vec::tail(args);
    let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")];
    let matches =
        match getopts::getopts(args_, opts) {
          ok(m) => m,
          err(f) => return either::right(getopts::fail_str(f))
        };

    let filter =
        if vec::len(matches.free) > 0u {
            option::some(matches.free[0])
        } else { option::none };

    let run_ignored = getopts::opt_present(matches, ~"ignored");
    let logfile = getopts::opt_maybe_str(matches, ~"logfile");

    let test_opts = {filter: filter, run_ignored: run_ignored,
                     logfile: logfile};

    return either::left(test_opts);
}

enum test_result { tr_ok, tr_failed, tr_ignored, }

type console_test_state =
    @{out: io::writer,
      log_out: option<io::writer>,
      use_color: bool,
      mut total: uint,
      mut passed: uint,
      mut failed: uint,
      mut ignored: uint,
      mut failures: ~[test_desc]};

// A simple console test runner
fn run_tests_console(opts: test_opts,
                     tests: ~[test_desc]) -> bool {

    fn callback(event: testevent, st: console_test_state) {
        match event {
          te_filtered(filtered_tests) => {
            st.total = vec::len(filtered_tests);
            let noun = if st.total != 1u { ~"tests" } else { ~"test" };
            st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun});
          }
          te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
          te_result(test, result) => {
            match st.log_out {
                some(f) => write_log(f, result, test),
                none => ()
            }
            match result {
              tr_ok => {
                st.passed += 1u;
                write_ok(st.out, st.use_color);
                st.out.write_line(~"");
              }
              tr_failed => {
                st.failed += 1u;
                write_failed(st.out, st.use_color);
                st.out.write_line(~"");
                vec::push(st.failures, copy test);
              }
              tr_ignored => {
                st.ignored += 1u;
                write_ignored(st.out, st.use_color);
                st.out.write_line(~"");
              }
            }
          }
        }
    }

    let log_out = match opts.logfile {
        some(path) => match io::file_writer(path,
                                            ~[io::create, io::truncate]) {
          result::ok(w) => some(w),
          result::err(s) => {
              fail(fmt!{"can't open output file: %s", s})
          }
        },
        none => none
    };

    let st =
        @{out: io::stdout(),
          log_out: log_out,
          use_color: use_color(),
          mut total: 0u,
          mut passed: 0u,
          mut failed: 0u,
          mut ignored: 0u,
          mut failures: ~[]};

    run_tests(opts, tests, |x| callback(x, st));

    assert (st.passed + st.failed + st.ignored == st.total);
    let success = st.failed == 0u;

    if !success {
        print_failures(st);
    }

    st.out.write_str(fmt!{"\nresult: "});
    if success {
        // There's no parallelism at this point so it's safe to use color
        write_ok(st.out, true);
    } else { write_failed(st.out, true); }
    st.out.write_str(fmt!{". %u passed; %u failed; %u ignored\n\n", st.passed,
                          st.failed, st.ignored});

    return success;

    fn write_log(out: io::writer, result: test_result, test: test_desc) {
        out.write_line(fmt!{"%s %s",
                    match result {
                        tr_ok => ~"ok",
                        tr_failed => ~"failed",
                        tr_ignored => ~"ignored"
                    }, test.name});
    }

    fn write_ok(out: io::writer, use_color: bool) {
        write_pretty(out, ~"ok", term::color_green, use_color);
    }

    fn write_failed(out: io::writer, use_color: bool) {
        write_pretty(out, ~"FAILED", term::color_red, use_color);
    }

    fn write_ignored(out: io::writer, use_color: bool) {
        write_pretty(out, ~"ignored", term::color_yellow, use_color);
    }

    fn write_pretty(out: io::writer, word: ~str, color: u8, use_color: bool) {
        if use_color && term::color_supported() {
            term::fg(out, color);
        }
        out.write_str(word);
        if use_color && term::color_supported() {
            term::reset(out);
        }
    }
}

fn print_failures(st: console_test_state) {
    st.out.write_line(~"\nfailures:");
    let failures = copy st.failures;
    let failures = vec::map(failures, |test| test.name);
    let failures = sort::merge_sort(str::le, failures);
    for vec::each(failures) |name| {
        st.out.write_line(fmt!{"    %s", name});
    }
}

#[test]
fn should_sort_failures_before_printing_them() {
    let buffer = io::mem_buffer();
    let writer = io::mem_buffer_writer(buffer);

    let test_a = {
        name: ~"a",
        fn: fn~() { },
        ignore: false,
        should_fail: false
    };

    let test_b = {
        name: ~"b",
        fn: fn~() { },
        ignore: false,
        should_fail: false
    };

    let st =
        @{out: writer,
          log_out: option::none,
          use_color: false,
          mut total: 0u,
          mut passed: 0u,
          mut failed: 0u,
          mut ignored: 0u,
          mut failures: ~[test_b, test_a]};

    print_failures(st);

    let s = io::mem_buffer_str(buffer);

    let apos = option::get(str::find_str(s, ~"a"));
    let bpos = option::get(str::find_str(s, ~"b"));
    assert apos < bpos;
}

fn use_color() -> bool { return get_concurrency() == 1u; }

enum testevent {
    te_filtered(~[test_desc]),
    te_wait(test_desc),
    te_result(test_desc, test_result),
}

type monitor_msg = (test_desc, test_result);

fn run_tests(opts: test_opts, tests: ~[test_desc],
             callback: fn@(testevent)) {

    let mut filtered_tests = filter_tests(opts, tests);
    callback(te_filtered(copy filtered_tests));

    // It's tempting to just spawn all the tests at once, but since we have
    // many tests that run in other processes we would be making a big mess.
    let concurrency = get_concurrency();
    debug!{"using %u test tasks", concurrency};

    let total = vec::len(filtered_tests);
    let mut run_idx = 0u;
    let mut wait_idx = 0u;
    let mut done_idx = 0u;

    let p = comm::port();
    let ch = comm::chan(p);

    while done_idx < total {
        while wait_idx < concurrency && run_idx < total {
            let test = copy filtered_tests[run_idx];
            if concurrency == 1u {
                // We are doing one test at a time so we can print the name
                // of the test before we run it. Useful for debugging tests
                // that hang forever.
                callback(te_wait(copy test));
            }
            run_test(test, ch);
            wait_idx += 1u;
            run_idx += 1u;
        }

        let (test, result) = comm::recv(p);
        if concurrency != 1u {
            callback(te_wait(copy test));
        }
        callback(te_result(test, result));
        wait_idx -= 1u;
        done_idx += 1u;
    }
}

// Windows tends to dislike being overloaded with threads.
#[cfg(windows)]
const sched_overcommit : uint = 1u;

#[cfg(unix)]
const sched_overcommit : uint = 4u;

fn get_concurrency() -> uint {
    let threads = rustrt::sched_threads() as uint;
    if threads == 1u { 1u }
    else { threads * sched_overcommit }
}

#[allow(non_implicitly_copyable_typarams)]
fn filter_tests(opts: test_opts,
                tests: ~[test_desc]) -> ~[test_desc] {
    let mut filtered = copy tests;

    // Remove tests that don't match the test filter
    filtered = if option::is_none(opts.filter) {
        filtered
    } else {
        let filter_str =
            match opts.filter {
          option::some(f) => f,
          option::none => ~""
        };

        fn filter_fn(test: test_desc, filter_str: ~str) ->
            option<test_desc> {
            if str::contains(test.name, filter_str) {
                return option::some(copy test);
            } else { return option::none; }
        }

        vec::filter_map(filtered, |x| filter_fn(x, filter_str))
    };

    // Maybe pull out the ignored test and unignore them
    filtered = if !opts.run_ignored {
        filtered
    } else {
        fn filter(test: test_desc) -> option<test_desc> {
            if test.ignore {
                return option::some({name: test.name,
                                  fn: copy test.fn,
                                  ignore: false,
                                  should_fail: test.should_fail});
            } else { return option::none; }
        };

        vec::filter_map(filtered, |x| filter(x))
    };

    // Sort the tests alphabetically
    filtered = {
        pure fn lteq(t1: &test_desc, t2: &test_desc) -> bool {
            str::le(&t1.name, &t2.name)
        }
        sort::merge_sort(lteq, filtered)
    };

    return filtered;
}

type test_future = {test: test_desc, wait: fn@() -> test_result};

fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
    if test.ignore {
        comm::send(monitor_ch, (copy test, tr_ignored));
        return;
    }

    do task::spawn {
        let testfn = copy test.fn;
        let mut result_future = none; // task::future_result(builder);
        task::task().unlinked().future_result(|+r| {
            result_future = some(r);
        }).spawn(testfn);
        let task_result = future::get(option::unwrap(result_future));
        let test_result = calc_result(test, task_result == task::success);
        comm::send(monitor_ch, (copy test, test_result));
    };
}

fn calc_result(test: test_desc, task_succeeded: bool) -> test_result {
    if task_succeeded {
        if test.should_fail { tr_failed }
        else { tr_ok }
    } else {
        if test.should_fail { tr_ok }
        else { tr_failed }
    }
}

#[cfg(test)]
mod tests {

    #[test]
    fn do_not_run_ignored_tests() {
        fn f() { fail; }
        let desc = {
            name: ~"whatever",
            fn: f,
            ignore: true,
            should_fail: false
        };
        let p = comm::port();
        let ch = comm::chan(p);
        run_test(desc, ch);
        let (_, res) = comm::recv(p);
        assert res != tr_ok;
    }

    #[test]
    fn ignored_tests_result_in_ignored() {
        fn f() { }
        let desc = {
            name: ~"whatever",
            fn: f,
            ignore: true,
            should_fail: false
        };
        let p = comm::port();
        let ch = comm::chan(p);
        run_test(desc, ch);
        let (_, res) = comm::recv(p);
        assert res == tr_ignored;
    }

    #[test]
    #[ignore(cfg(windows))]
    fn test_should_fail() {
        fn f() { fail; }
        let desc = {
            name: ~"whatever",
            fn: f,
            ignore: false,
            should_fail: true
        };
        let p = comm::port();
        let ch = comm::chan(p);
        run_test(desc, ch);
        let (_, res) = comm::recv(p);
        assert res == tr_ok;
    }

    #[test]
    fn test_should_fail_but_succeeds() {
        fn f() { }
        let desc = {
            name: ~"whatever",
            fn: f,
            ignore: false,
            should_fail: true
        };
        let p = comm::port();
        let ch = comm::chan(p);
        run_test(desc, ch);
        let (_, res) = comm::recv(p);
        assert res == tr_failed;
    }

    #[test]
    fn first_free_arg_should_be_a_filter() {
        let args = ~[~"progname", ~"filter"];
        let opts = match parse_opts(args) {
          either::left(o) => o,
          _ => fail ~"Malformed arg in first_free_arg_should_be_a_filter"
        };
        assert ~"filter" == option::get(opts.filter);
    }

    #[test]
    fn parse_ignored_flag() {
        let args = ~[~"progname", ~"filter", ~"--ignored"];
        let opts = match parse_opts(args) {
          either::left(o) => o,
          _ => fail ~"Malformed arg in parse_ignored_flag"
        };
        assert (opts.run_ignored);
    }

    #[test]
    fn filter_for_ignored_option() {
        // When we run ignored tests the test filter should filter out all the
        // unignored tests and flip the ignore flag on the rest to false

        let opts = {filter: option::none, run_ignored: true,
            logfile: option::none};
        let tests =
            ~[{name: ~"1", fn: fn~() { }, ignore: true, should_fail: false},
             {name: ~"2", fn: fn~() { }, ignore: false, should_fail: false}];
        let filtered = filter_tests(opts, tests);

        assert (vec::len(filtered) == 1u);
        assert (filtered[0].name == ~"1");
        assert (filtered[0].ignore == false);
    }

    #[test]
    fn sort_tests() {
        let opts = {filter: option::none, run_ignored: false,
            logfile: option::none};

        let names =
            ~[~"sha1::test", ~"int::test_to_str", ~"int::test_pow",
             ~"test::do_not_run_ignored_tests",
             ~"test::ignored_tests_result_in_ignored",
             ~"test::first_free_arg_should_be_a_filter",
             ~"test::parse_ignored_flag", ~"test::filter_for_ignored_option",
             ~"test::sort_tests"];
        let tests =
        {
        let testfn = fn~() { };
        let mut tests = ~[];
            for vec::each(names) |name| {
            let test = {name: name, fn: copy testfn, ignore: false,
                        should_fail: false};
            tests += ~[test];
        }
        tests
    };
    let filtered = filter_tests(opts, tests);

    let expected =
        ~[~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
          ~"test::do_not_run_ignored_tests",
          ~"test::filter_for_ignored_option",
          ~"test::first_free_arg_should_be_a_filter",
          ~"test::ignored_tests_result_in_ignored",
          ~"test::parse_ignored_flag",
          ~"test::sort_tests"];

    let pairs = vec::zip(expected, filtered);

    for vec::each(pairs) |p| { let (a, b) = copy p; assert (a == b.name); }
}
}


// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: