vendor/kyua/0.13-a685f91vendor/kyua

1 files changed, 476 insertions, 0 deletions

diff --git a/engine/scanner_test.cpp b/engine/scanner_test.cpp
new file mode 100644
index 0000000000000..f79717eca49e9
--- /dev/null
+++ b/engine/scanner_test.cpp
@@ -0,0 +1,476 @@
+// 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);
+}