// Copyright 2014 The Kyua Authors.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
// * Neither the name of Google Inc. nor the names of its contributors
//   may be used to endorse or promote products derived from this software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "engine/scanner.hpp"

#include <cstdarg>
#include <cstddef>
#include <typeinfo>

#include <atf-c++.hpp>

#include "engine/filters.hpp"
#include "model/metadata.hpp"
#include "model/test_case.hpp"
#include "model/test_program.hpp"
#include "utils/format/containers.ipp"
#include "utils/fs/path.hpp"
#include "utils/optional.ipp"

namespace fs = utils::fs;

using utils::optional;


namespace {


/// Test program that implements a mock test_cases() lazy call.
class mock_test_program : public model::test_program {
    /// Number of times test_cases has been called.
    mutable std::size_t _num_calls;

    /// Collection of test cases; lazily initialized.
    mutable model::test_cases_map _test_cases;

public:
    /// Constructs a new test program.
    ///
    /// \param binary_ The name of the test program binary relative to root_.
    mock_test_program(const fs::path& binary_) :
        test_program("unused-interface", binary_, fs::path("unused-root"),
                     "unused-suite", model::metadata_builder().build(),
                     model::test_cases_map()),
        _num_calls(0)
    {
    }

    /// Gets or loads the list of test cases from the test program.
    ///
    /// \return The list of test cases provided by the test program.
    const model::test_cases_map&
    test_cases(void) const
    {
        if (_num_calls == 0) {
            const model::metadata metadata = model::metadata_builder().build();
            const model::test_case tc1("one", metadata);
            const model::test_case tc2("two", metadata);
            _test_cases.insert(model::test_cases_map::value_type("one", tc1));
            _test_cases.insert(model::test_cases_map::value_type("two", tc2));
        }
        _num_calls++;
        return _test_cases;
    }

    /// Returns the number of times test_cases() has been called.
    ///
    /// \return A counter.
    std::size_t
    num_calls(void) const
    {
        return _num_calls;
    }
};


/// Syntactic sugar to instantiate a test program with various test cases.
///
/// The scanner only cares about the relative path of the test program object
/// and the names of the test cases.  This function helps in instantiating a
/// test program that has the minimum set of details only.
///
/// \param relative_path Relative path to the test program.
/// \param ... List of test case names to add to the test program.  Must be
///     NULL-terminated.
///
/// \return A constructed test program.
static model::test_program_ptr
new_test_program(const char* relative_path, ...)
{
    model::test_program_builder builder(
        "unused-interface", fs::path(relative_path), fs::path("unused-root"),
        "unused-suite");

    va_list ap;
    va_start(ap, relative_path);
    const char* test_case_name;
    while ((test_case_name = va_arg(ap, const char*)) != NULL) {
        builder.add_test_case(test_case_name);
    }
    va_end(ap);

    return builder.build_ptr();
}


/// Yields all test cases in the scanner for simplicity of testing.
///
/// In most of the tests below, we just care about the scanner returning the
/// full set of matching test cases, not the specific behavior of every single
/// yield() call.  This function just returns the whole set, which helps in
/// writing functional tests.
///
/// \param scanner The scanner on which to iterate.
///
/// \return The full collection of results yielded by the scanner.
static std::set< engine::scan_result >
yield_all(engine::scanner& scanner)
{
    std::set< engine::scan_result > results;
    while (!scanner.done()) {
        const optional< engine::scan_result > result = scanner.yield();
        ATF_REQUIRE(result);
        results.insert(result.get());
    }
    ATF_REQUIRE(!scanner.yield());
    ATF_REQUIRE(scanner.done());
    return results;
}


}  // anonymous namespace


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__no_tests);
ATF_TEST_CASE_BODY(scanner__no_filters__no_tests)
{
    const model::test_programs_vector test_programs;
    const std::set< engine::test_filter > filters;

    engine::scanner scanner(test_programs, filters);
    ATF_REQUIRE(scanner.done());
    ATF_REQUIRE(!scanner.yield());
    ATF_REQUIRE(scanner.unused_filters().empty());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__one_test_in_one_program);
ATF_TEST_CASE_BODY(scanner__no_filters__one_test_in_one_program)
{
    const model::test_program_ptr test_program = new_test_program(
        "dir/program", "lone_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program);

    const std::set< engine::test_filter > filters;

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program, "lone_test"));

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__one_test_per_many_programs);
ATF_TEST_CASE_BODY(scanner__no_filters__one_test_per_many_programs)
{
    const model::test_program_ptr test_program1 = new_test_program(
        "dir/program1", "foo_test", NULL);
    const model::test_program_ptr test_program2 = new_test_program(
        "program2", "bar_test", NULL);
    const model::test_program_ptr test_program3 = new_test_program(
        "a/b/c/d/e/program3", "baz_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);
    test_programs.push_back(test_program3);

    const std::set< engine::test_filter > filters;

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program1, "foo_test"));
    exp_results.insert(engine::scan_result(test_program2, "bar_test"));
    exp_results.insert(engine::scan_result(test_program3, "baz_test"));

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__many_tests_in_one_program);
ATF_TEST_CASE_BODY(scanner__no_filters__many_tests_in_one_program)
{
    const model::test_program_ptr test_program = new_test_program(
        "dir/program", "first_test", "second_test", "third_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program);

    const std::set< engine::test_filter > filters;

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program, "first_test"));
    exp_results.insert(engine::scan_result(test_program, "second_test"));
    exp_results.insert(engine::scan_result(test_program, "third_test"));

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__many_tests_per_many_programs);
ATF_TEST_CASE_BODY(scanner__no_filters__many_tests_per_many_programs)
{
    const model::test_program_ptr test_program1 = new_test_program(
        "dir/program1", "foo_test", "bar_test", "baz_test", NULL);
    const model::test_program_ptr test_program2 = new_test_program(
        "program2", "lone_test", NULL);
    const model::test_program_ptr test_program3 = new_test_program(
        "a/b/c/d/e/program3", "another_test", "last_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);
    test_programs.push_back(test_program3);

    const std::set< engine::test_filter > filters;

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program1, "foo_test"));
    exp_results.insert(engine::scan_result(test_program1, "bar_test"));
    exp_results.insert(engine::scan_result(test_program1, "baz_test"));
    exp_results.insert(engine::scan_result(test_program2, "lone_test"));
    exp_results.insert(engine::scan_result(test_program3, "another_test"));
    exp_results.insert(engine::scan_result(test_program3, "last_test"));

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__no_filters__verify_lazy_loads);
ATF_TEST_CASE_BODY(scanner__no_filters__verify_lazy_loads)
{
    const model::test_program_ptr test_program1(new mock_test_program(
        fs::path("first")));
    const mock_test_program* mock_program1 =
        dynamic_cast< const mock_test_program* >(test_program1.get());
    const model::test_program_ptr test_program2(new mock_test_program(
        fs::path("second")));
    const mock_test_program* mock_program2 =
        dynamic_cast< const mock_test_program* >(test_program2.get());

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);

    const std::set< engine::test_filter > filters;

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program1, "one"));
    exp_results.insert(engine::scan_result(test_program1, "two"));
    exp_results.insert(engine::scan_result(test_program2, "one"));
    exp_results.insert(engine::scan_result(test_program2, "two"));

    engine::scanner scanner(test_programs, filters);
    std::set< engine::scan_result > results;
    ATF_REQUIRE_EQ(0, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());

    // This abuses the internal implementation of the scanner by making
    // assumptions on the order of the results.
    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());
    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());
    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(1, mock_program2->num_calls());
    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(1, mock_program2->num_calls());
    ATF_REQUIRE(scanner.done());

    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());

    // Make sure we are still talking to the original objects.
    for (std::set< engine::scan_result >::const_iterator iter = results.begin();
         iter != results.end(); ++iter) {
        const mock_test_program* mock_program =
            dynamic_cast< const mock_test_program* >((*iter).first.get());
        ATF_REQUIRE_EQ(1, mock_program->num_calls());
    }
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__with_filters__no_tests);
ATF_TEST_CASE_BODY(scanner__with_filters__no_tests)
{
    const model::test_programs_vector test_programs;

    std::set< engine::test_filter > filters;
    filters.insert(engine::test_filter(fs::path("foo"), "bar"));

    engine::scanner scanner(test_programs, filters);
    ATF_REQUIRE(scanner.done());
    ATF_REQUIRE(!scanner.yield());
    ATF_REQUIRE_EQ(filters, scanner.unused_filters());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__with_filters__no_matches);
ATF_TEST_CASE_BODY(scanner__with_filters__no_matches)
{
    const model::test_program_ptr test_program1 = new_test_program(
        "dir/program1", "foo_test", "bar_test", "baz_test", NULL);
    const model::test_program_ptr test_program2 = new_test_program(
        "dir/program2", "bar_test", NULL);
    const model::test_program_ptr test_program3 = new_test_program(
        "program3", "another_test", "last_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);
    test_programs.push_back(test_program3);

    std::set< engine::test_filter > filters;
    filters.insert(engine::test_filter(fs::path("dir/program2"), "baz_test"));
    filters.insert(engine::test_filter(fs::path("program4"), "another_test"));
    filters.insert(engine::test_filter(fs::path("dir/program3"), ""));

    const std::set< engine::scan_result > exp_results;

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE_EQ(filters, scanner.unused_filters());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__with_filters__some_matches);
ATF_TEST_CASE_BODY(scanner__with_filters__some_matches)
{
    const model::test_program_ptr test_program1 = new_test_program(
        "dir/program1", "foo_test", "bar_test", "baz_test", NULL);
    const model::test_program_ptr test_program2 = new_test_program(
        "dir/program2", "bar_test", NULL);
    const model::test_program_ptr test_program3 = new_test_program(
        "program3", "another_test", "last_test", NULL);
    const model::test_program_ptr test_program4 = new_test_program(
        "program4", "more_test", NULL);

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);
    test_programs.push_back(test_program3);
    test_programs.push_back(test_program4);

    std::set< engine::test_filter > filters;
    filters.insert(engine::test_filter(fs::path("dir/program1"), "baz_test"));
    filters.insert(engine::test_filter(fs::path("dir/program2"), "foo_test"));
    filters.insert(engine::test_filter(fs::path("program3"), ""));

    std::set< engine::test_filter > exp_filters;
    exp_filters.insert(engine::test_filter(fs::path("dir/program2"),
                                           "foo_test"));

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program1, "baz_test"));
    exp_results.insert(engine::scan_result(test_program3, "another_test"));
    exp_results.insert(engine::scan_result(test_program3, "last_test"));

    engine::scanner scanner(test_programs, filters);
    const std::set< engine::scan_result > results = yield_all(scanner);
    ATF_REQUIRE_EQ(exp_results, results);

    ATF_REQUIRE_EQ(exp_filters, scanner.unused_filters());
}


ATF_TEST_CASE_WITHOUT_HEAD(scanner__with_filters__verify_lazy_loads);
ATF_TEST_CASE_BODY(scanner__with_filters__verify_lazy_loads)
{
    const model::test_program_ptr test_program1(new mock_test_program(
        fs::path("first")));
    const mock_test_program* mock_program1 =
        dynamic_cast< const mock_test_program* >(test_program1.get());
    const model::test_program_ptr test_program2(new mock_test_program(
        fs::path("second")));
    const mock_test_program* mock_program2 =
        dynamic_cast< const mock_test_program* >(test_program2.get());

    model::test_programs_vector test_programs;
    test_programs.push_back(test_program1);
    test_programs.push_back(test_program2);

    std::set< engine::test_filter > filters;
    filters.insert(engine::test_filter(fs::path("first"), ""));

    std::set< engine::scan_result > exp_results;
    exp_results.insert(engine::scan_result(test_program1, "one"));
    exp_results.insert(engine::scan_result(test_program1, "two"));

    engine::scanner scanner(test_programs, filters);
    std::set< engine::scan_result > results;
    ATF_REQUIRE_EQ(0, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());

    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());
    results.insert(scanner.yield().get());
    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());
    ATF_REQUIRE(scanner.done());

    ATF_REQUIRE_EQ(exp_results, results);
    ATF_REQUIRE(scanner.unused_filters().empty());

    ATF_REQUIRE_EQ(1, mock_program1->num_calls());
    ATF_REQUIRE_EQ(0, mock_program2->num_calls());
}


ATF_INIT_TEST_CASES(tcs)
{
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__no_tests);
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__one_test_in_one_program);
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__one_test_per_many_programs);
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__many_tests_in_one_program);
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__many_tests_per_many_programs);
    ATF_ADD_TEST_CASE(tcs, scanner__no_filters__verify_lazy_loads);

    ATF_ADD_TEST_CASE(tcs, scanner__with_filters__no_tests);
    ATF_ADD_TEST_CASE(tcs, scanner__with_filters__no_matches);
    ATF_ADD_TEST_CASE(tcs, scanner__with_filters__some_matches);
    ATF_ADD_TEST_CASE(tcs, scanner__with_filters__verify_lazy_loads);
}