aboutsummaryrefslogtreecommitdiffstats
path: root/model/test_program.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'model/test_program.cpp')
-rw-r--r--model/test_program.cpp452
1 files changed, 452 insertions, 0 deletions
diff --git a/model/test_program.cpp b/model/test_program.cpp
new file mode 100644
index 000000000000..b9181aa49537
--- /dev/null
+++ b/model/test_program.cpp
@@ -0,0 +1,452 @@
+// Copyright 2010 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 "model/test_program.hpp"
+
+#include <map>
+#include <sstream>
+
+#include "model/exceptions.hpp"
+#include "model/metadata.hpp"
+#include "model/test_case.hpp"
+#include "model/test_result.hpp"
+#include "utils/format/containers.ipp"
+#include "utils/format/macros.hpp"
+#include "utils/fs/path.hpp"
+#include "utils/noncopyable.hpp"
+#include "utils/sanity.hpp"
+#include "utils/text/operations.ipp"
+
+namespace fs = utils::fs;
+namespace text = utils::text;
+
+using utils::none;
+
+
+/// Internal implementation of a test_program.
+struct model::test_program::impl : utils::noncopyable {
+ /// Name of the test program interface.
+ std::string interface_name;
+
+ /// Name of the test program binary relative to root.
+ fs::path binary;
+
+ /// Root of the test suite containing the test program.
+ fs::path root;
+
+ /// Name of the test suite this program belongs to.
+ std::string test_suite_name;
+
+ /// Metadata of the test program.
+ model::metadata md;
+
+ /// List of test cases in the test program.
+ ///
+ /// Must be queried via the test_program::test_cases() method.
+ model::test_cases_map test_cases;
+
+ /// Constructor.
+ ///
+ /// \param interface_name_ Name of the test program interface.
+ /// \param binary_ The name of the test program binary relative to root_.
+ /// \param root_ The root of the test suite containing the test program.
+ /// \param test_suite_name_ The name of the test suite this program
+ /// belongs to.
+ /// \param md_ Metadata of the test program.
+ /// \param test_cases_ The collection of test cases in the test program.
+ impl(const std::string& interface_name_, const fs::path& binary_,
+ const fs::path& root_, const std::string& test_suite_name_,
+ const model::metadata& md_, const model::test_cases_map& test_cases_) :
+ interface_name(interface_name_),
+ binary(binary_),
+ root(root_),
+ test_suite_name(test_suite_name_),
+ md(md_)
+ {
+ PRE_MSG(!binary.is_absolute(),
+ F("The program '%s' must be relative to the root of the test "
+ "suite '%s'") % binary % root);
+
+ set_test_cases(test_cases_);
+ }
+
+ /// Sets the list of test cases of the test program.
+ ///
+ /// \param test_cases_ The new list of test cases.
+ void
+ set_test_cases(const model::test_cases_map& test_cases_)
+ {
+ for (model::test_cases_map::const_iterator iter = test_cases_.begin();
+ iter != test_cases_.end(); ++iter) {
+ const std::string& name = (*iter).first;
+ const model::test_case& test_case = (*iter).second;
+
+ PRE_MSG(name == test_case.name(),
+ F("The test case '%s' has been registered with the "
+ "non-matching name '%s'") % name % test_case.name());
+
+ test_cases.insert(model::test_cases_map::value_type(
+ name, test_case.apply_metadata_defaults(&md)));
+ }
+ INV(test_cases.size() == test_cases_.size());
+ }
+};
+
+
+/// Constructs a new test program.
+///
+/// \param interface_name_ Name of the test program interface.
+/// \param binary_ The name of the test program binary relative to root_.
+/// \param root_ The root of the test suite containing the test program.
+/// \param test_suite_name_ The name of the test suite this program belongs to.
+/// \param md_ Metadata of the test program.
+/// \param test_cases_ The collection of test cases in the test program.
+model::test_program::test_program(const std::string& interface_name_,
+ const fs::path& binary_,
+ const fs::path& root_,
+ const std::string& test_suite_name_,
+ const model::metadata& md_,
+ const model::test_cases_map& test_cases_) :
+ _pimpl(new impl(interface_name_, binary_, root_, test_suite_name_, md_,
+ test_cases_))
+{
+}
+
+
+/// Destroys a test program.
+model::test_program::~test_program(void)
+{
+}
+
+
+/// Gets the name of the test program interface.
+///
+/// \return An interface name.
+const std::string&
+model::test_program::interface_name(void) const
+{
+ return _pimpl->interface_name;
+}
+
+
+/// Gets the path to the test program relative to the root of the test suite.
+///
+/// \return The relative path to the test program binary.
+const fs::path&
+model::test_program::relative_path(void) const
+{
+ return _pimpl->binary;
+}
+
+
+/// Gets the absolute path to the test program.
+///
+/// \return The absolute path to the test program binary.
+const fs::path
+model::test_program::absolute_path(void) const
+{
+ const fs::path full_path = _pimpl->root / _pimpl->binary;
+ return full_path.is_absolute() ? full_path : full_path.to_absolute();
+}
+
+
+/// Gets the root of the test suite containing this test program.
+///
+/// \return The path to the root of the test suite.
+const fs::path&
+model::test_program::root(void) const
+{
+ return _pimpl->root;
+}
+
+
+/// Gets the name of the test suite containing this test program.
+///
+/// \return The name of the test suite.
+const std::string&
+model::test_program::test_suite_name(void) const
+{
+ return _pimpl->test_suite_name;
+}
+
+
+/// Gets the metadata of the test program.
+///
+/// \return The metadata.
+const model::metadata&
+model::test_program::get_metadata(void) const
+{
+ return _pimpl->md;
+}
+
+
+/// Gets a test case by its name.
+///
+/// \param name The name of the test case to locate.
+///
+/// \return The requested test case.
+///
+/// \throw not_found_error If the specified test case is not in the test
+/// program.
+const model::test_case&
+model::test_program::find(const std::string& name) const
+{
+ const test_cases_map& tcs = test_cases();
+
+ const test_cases_map::const_iterator iter = tcs.find(name);
+ if (iter == tcs.end())
+ throw not_found_error(F("Unknown test case %s in test program %s") %
+ name % relative_path());
+ return (*iter).second;
+}
+
+
+/// Gets 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&
+model::test_program::test_cases(void) const
+{
+ return _pimpl->test_cases;
+}
+
+
+/// Sets the list of test cases of the test program.
+///
+/// This can only be called once and it may only be called from within
+/// overridden test_cases() before that method ever returns a value for the
+/// first time. Any other invocations will result in inconsistent program
+/// state.
+///
+/// \param test_cases_ The new list of test cases.
+void
+model::test_program::set_test_cases(const model::test_cases_map& test_cases_)
+{
+ PRE(_pimpl->test_cases.empty());
+ _pimpl->set_test_cases(test_cases_);
+}
+
+
+/// Equality comparator.
+///
+/// \param other The other object to compare this one to.
+///
+/// \return True if this object and other are equal; false otherwise.
+bool
+model::test_program::operator==(const test_program& other) const
+{
+ return _pimpl == other._pimpl || (
+ _pimpl->interface_name == other._pimpl->interface_name &&
+ _pimpl->binary == other._pimpl->binary &&
+ _pimpl->root == other._pimpl->root &&
+ _pimpl->test_suite_name == other._pimpl->test_suite_name &&
+ _pimpl->md == other._pimpl->md &&
+ test_cases() == other.test_cases());
+}
+
+
+/// Inequality comparator.
+///
+/// \param other The other object to compare this one to.
+///
+/// \return True if this object and other are different; false otherwise.
+bool
+model::test_program::operator!=(const test_program& other) const
+{
+ return !(*this == other);
+}
+
+
+/// Less-than comparator.
+///
+/// A test program is considered to be less than another if and only if the
+/// former's absolute path is less than the absolute path of the latter. In
+/// other words, the absolute path is used here as the test program's
+/// identifier.
+///
+/// This simplistic less-than operator overload is provided so that test
+/// programs can be held in sets and other containers.
+///
+/// \param other The other object to compare this one to.
+///
+/// \return True if this object sorts before the other object; false otherwise.
+bool
+model::test_program::operator<(const test_program& other) const
+{
+ return absolute_path() < other.absolute_path();
+}
+
+
+/// Injects the object into a stream.
+///
+/// \param output The stream into which to inject the object.
+/// \param object The object to format.
+///
+/// \return The output stream.
+std::ostream&
+model::operator<<(std::ostream& output, const test_program& object)
+{
+ output << F("test_program{interface=%s, binary=%s, root=%s, test_suite=%s, "
+ "metadata=%s, test_cases=%s}")
+ % text::quote(object.interface_name(), '\'')
+ % text::quote(object.relative_path().str(), '\'')
+ % text::quote(object.root().str(), '\'')
+ % text::quote(object.test_suite_name(), '\'')
+ % object.get_metadata()
+ % object.test_cases();
+ return output;
+}
+
+
+/// Internal implementation of the test_program_builder class.
+struct model::test_program_builder::impl : utils::noncopyable {
+ /// Partially-constructed program with only the required properties.
+ model::test_program prototype;
+
+ /// Optional metadata for the test program.
+ model::metadata metadata;
+
+ /// Collection of test cases.
+ model::test_cases_map test_cases;
+
+ /// Whether we have created a test_program object or not.
+ bool built;
+
+ /// Constructor.
+ ///
+ /// \param prototype_ The partially constructed program with only the
+ /// required properties.
+ impl(const model::test_program& prototype_) :
+ prototype(prototype_),
+ metadata(model::metadata_builder().build()),
+ built(false)
+ {
+ }
+};
+
+
+/// Constructs a new builder with non-optional values.
+///
+/// \param interface_name_ Name of the test program interface.
+/// \param binary_ The name of the test program binary relative to root_.
+/// \param root_ The root of the test suite containing the test program.
+/// \param test_suite_name_ The name of the test suite this program belongs to.
+model::test_program_builder::test_program_builder(
+ const std::string& interface_name_, const fs::path& binary_,
+ const fs::path& root_, const std::string& test_suite_name_) :
+ _pimpl(new impl(model::test_program(interface_name_, binary_, root_,
+ test_suite_name_,
+ model::metadata_builder().build(),
+ model::test_cases_map())))
+{
+}
+
+
+/// Destructor.
+model::test_program_builder::~test_program_builder(void)
+{
+}
+
+
+/// Accumulates an additional test case with default metadata.
+///
+/// \param test_case_name The name of the test case.
+///
+/// \return A reference to this builder.
+model::test_program_builder&
+model::test_program_builder::add_test_case(const std::string& test_case_name)
+{
+ return add_test_case(test_case_name, model::metadata_builder().build());
+}
+
+
+/// Accumulates an additional test case.
+///
+/// \param test_case_name The name of the test case.
+/// \param metadata The test case metadata.
+///
+/// \return A reference to this builder.
+model::test_program_builder&
+model::test_program_builder::add_test_case(const std::string& test_case_name,
+ const model::metadata& metadata)
+{
+ const model::test_case test_case(test_case_name, metadata);
+ PRE_MSG(_pimpl->test_cases.find(test_case_name) == _pimpl->test_cases.end(),
+ F("Attempted to re-register test case '%s'") % test_case_name);
+ _pimpl->test_cases.insert(model::test_cases_map::value_type(
+ test_case_name, test_case));
+ return *this;
+}
+
+
+/// Sets the test program metadata.
+///
+/// \return metadata The metadata for the test program.
+///
+/// \return A reference to this builder.
+model::test_program_builder&
+model::test_program_builder::set_metadata(const model::metadata& metadata)
+{
+ _pimpl->metadata = metadata;
+ return *this;
+}
+
+
+/// Creates a new test_program object.
+///
+/// \pre This has not yet been called. We only support calling this function
+/// once.
+///
+/// \return The constructed test_program object.
+model::test_program
+model::test_program_builder::build(void) const
+{
+ PRE(!_pimpl->built);
+ _pimpl->built = true;
+
+ return test_program(_pimpl->prototype.interface_name(),
+ _pimpl->prototype.relative_path(),
+ _pimpl->prototype.root(),
+ _pimpl->prototype.test_suite_name(),
+ _pimpl->metadata,
+ _pimpl->test_cases);
+}
+
+
+/// Creates a new dynamically-allocated test_program object.
+///
+/// \pre This has not yet been called. We only support calling this function
+/// once.
+///
+/// \return The constructed test_program object.
+model::test_program_ptr
+model::test_program_builder::build_ptr(void) const
+{
+ const test_program result = build();
+ return test_program_ptr(new test_program(result));
+}