boost/beast/_experimental/unit_test/suite.hpp
// // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_SUITE_HPP #define BOOST_BEAST_UNIT_TEST_SUITE_HPP #include <boost/beast/_experimental/unit_test/runner.hpp> #include <boost/throw_exception.hpp> #include <ostream> #include <sstream> #include <string> namespace boost { namespace beast { namespace unit_test { namespace detail { template<class String> std::string make_reason(String const& reason, char const* file, int line) { std::string s(reason); if(! s.empty()) s.append(": "); char const* path = file + strlen(file); while(path != file) { #ifdef _MSC_VER if(path[-1] == '\\') #else if(path[-1] == '/') #endif break; --path; } s.append(path); s.append("("); s.append(std::to_string(line)); s.append(")"); return s; } } // detail class thread; enum abort_t { no_abort_on_fail, abort_on_fail }; /** A testsuite class. Derived classes execute a series of testcases, where each testcase is a series of pass/fail tests. To provide a unit test using this class, derive from it and use the BOOST_BEAST_DEFINE_UNIT_TEST macro in a translation unit. */ class suite { private: bool abort_ = false; bool aborted_ = false; runner* runner_ = nullptr; // This exception is thrown internally to stop the current suite // in the event of a failure, if the option to stop is set. struct abort_exception : public std::exception { char const* what() const noexcept override { return "test suite aborted"; } }; template<class CharT, class Traits, class Allocator> class log_buf : public std::basic_stringbuf<CharT, Traits, Allocator> { suite& suite_; public: explicit log_buf(suite& self) : suite_(self) { } ~log_buf() { sync(); } int sync() override { auto const& s = this->str(); if(s.size() > 0) suite_.runner_->log(s); this->str(""); return 0; } }; template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class log_os : public std::basic_ostream<CharT, Traits> { log_buf<CharT, Traits, Allocator> buf_; public: explicit log_os(suite& self) : std::basic_ostream<CharT, Traits>(&buf_) , buf_(self) { } }; class scoped_testcase; class testcase_t { suite& suite_; std::stringstream ss_; public: explicit testcase_t(suite& self) : suite_(self) { } /** Open a new testcase. A testcase is a series of evaluated test conditions. A test suite may have multiple test cases. A test is associated with the last opened testcase. When the test first runs, a default unnamed case is opened. Tests with only one case may omit the call to testcase. @param abort Determines if suite continues running after a failure. */ void operator()(std::string const& name, abort_t abort = no_abort_on_fail); scoped_testcase operator()(abort_t abort); template<class T> scoped_testcase operator<<(T const& t); }; public: /** Logging output stream. Text sent to the log output stream will be forwarded to the output stream associated with the runner. */ log_os<char> log; /** Memberspace for declaring test cases. */ testcase_t testcase; /** Returns the "current" running suite. If no suite is running, nullptr is returned. */ static suite* this_suite() { return *p_this_suite(); } suite() : log(*this) , testcase(*this) { } virtual ~suite() = default; suite(suite const&) = delete; suite& operator=(suite const&) = delete; /** Invokes the test using the specified runner. Data members are set up here instead of the constructor as a convenience to writing the derived class to avoid repetition of forwarded constructor arguments to the base. Normally this is called by the framework for you. */ template<class = void> void operator()(runner& r); /** Record a successful test condition. */ template<class = void> void pass(); /** Record a failure. @param reason Optional text added to the output on a failure. @param file The source code file where the test failed. @param line The source code line number where the test failed. */ /** @{ */ template<class String> void fail(String const& reason, char const* file, int line); template<class = void> void fail(std::string const& reason = ""); /** @} */ /** Evaluate a test condition. This function provides improved logging by incorporating the file name and line number into the reported output on failure, as well as additional text specified by the caller. @param shouldBeTrue The condition to test. The condition is evaluated in a boolean context. @param reason Optional added text to output on a failure. @param file The source code file where the test failed. @param line The source code line number where the test failed. @return `true` if the test condition indicates success. */ /** @{ */ template<class Condition> bool expect(Condition const& shouldBeTrue) { return expect(shouldBeTrue, ""); } template<class Condition, class String> bool expect(Condition const& shouldBeTrue, String const& reason); template<class Condition> bool expect(Condition const& shouldBeTrue, char const* file, int line) { return expect(shouldBeTrue, "", file, line); } template<class Condition, class String> bool expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line); /** @} */ // // DEPRECATED // // Expect an exception from f() template<class F, class String> bool except(F&& f, String const& reason); template<class F> bool except(F&& f) { return except(f, ""); } template<class E, class F, class String> bool except(F&& f, String const& reason); template<class E, class F> bool except(F&& f) { return except<E>(f, ""); } template<class F, class String> bool unexcept(F&& f, String const& reason); template<class F> bool unexcept(F&& f) { return unexcept(f, ""); } /** Return the argument associated with the runner. */ std::string const& arg() const { return runner_->arg(); } // DEPRECATED // @return `true` if the test condition indicates success(a false value) template<class Condition, class String> bool unexpected(Condition shouldBeFalse, String const& reason); template<class Condition> bool unexpected(Condition shouldBeFalse) { return unexpected(shouldBeFalse, ""); } private: friend class thread; static suite** p_this_suite() { static suite* pts = nullptr; return &pts; } /** Runs the suite. */ virtual void run() = 0; void propagate_abort(); template<class = void> void run(runner& r); }; //------------------------------------------------------------------------------ // Helper for streaming testcase names class suite::scoped_testcase { private: suite& suite_; std::stringstream& ss_; public: scoped_testcase& operator=(scoped_testcase const&) = delete; ~scoped_testcase() { auto const& name = ss_.str(); if(! name.empty()) suite_.runner_->testcase(name); } scoped_testcase(suite& self, std::stringstream& ss) : suite_(self) , ss_(ss) { ss_.clear(); ss_.str({}); } template<class T> scoped_testcase(suite& self, std::stringstream& ss, T const& t) : suite_(self) , ss_(ss) { ss_.clear(); ss_.str({}); ss_ << t; } template<class T> scoped_testcase& operator<<(T const& t) { ss_ << t; return *this; } }; //------------------------------------------------------------------------------ inline void suite::testcase_t::operator()( std::string const& name, abort_t abort) { suite_.abort_ = abort == abort_on_fail; suite_.runner_->testcase(name); } inline suite::scoped_testcase suite::testcase_t::operator()(abort_t abort) { suite_.abort_ = abort == abort_on_fail; return { suite_, ss_ }; } template<class T> inline suite::scoped_testcase suite::testcase_t::operator<<(T const& t) { return { suite_, ss_, t }; } //------------------------------------------------------------------------------ template<class> void suite:: operator()(runner& r) { *p_this_suite() = this; try { run(r); *p_this_suite() = nullptr; } catch(...) { *p_this_suite() = nullptr; throw; } } template<class Condition, class String> bool suite:: expect( Condition const& shouldBeTrue, String const& reason) { if(shouldBeTrue) { pass(); return true; } fail(reason); return false; } template<class Condition, class String> bool suite:: expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line) { if(shouldBeTrue) { pass(); return true; } fail(detail::make_reason(reason, file, line)); return false; } // DEPRECATED template<class F, class String> bool suite:: except(F&& f, String const& reason) { try { f(); fail(reason); return false; } catch(...) { pass(); } return true; } template<class E, class F, class String> bool suite:: except(F&& f, String const& reason) { try { f(); fail(reason); return false; } catch(E const&) { pass(); } return true; } template<class F, class String> bool suite:: unexcept(F&& f, String const& reason) { try { f(); pass(); return true; } catch(...) { fail(reason); } return false; } template<class Condition, class String> bool suite:: unexpected( Condition shouldBeFalse, String const& reason) { bool const b = static_cast<bool>(shouldBeFalse); if(! b) pass(); else fail(reason); return ! b; } template<class> void suite:: pass() { propagate_abort(); runner_->pass(); } // ::fail template<class> void suite:: fail(std::string const& reason) { propagate_abort(); runner_->fail(reason); if(abort_) { aborted_ = true; BOOST_THROW_EXCEPTION(abort_exception()); } } template<class String> void suite:: fail(String const& reason, char const* file, int line) { fail(detail::make_reason(reason, file, line)); } inline void suite:: propagate_abort() { if(abort_ && aborted_) BOOST_THROW_EXCEPTION(abort_exception()); } template<class> void suite:: run(runner& r) { runner_ = &r; try { run(); } catch(abort_exception const&) { // ends the suite } catch(std::exception const& e) { runner_->fail("unhandled exception: " + std::string(e.what())); } catch(...) { runner_->fail("unhandled exception"); } } #ifndef BEAST_PASS #define BEAST_PASS() ::boost::beast::unit_test::suite::this_suite()->pass() #endif #ifndef BEAST_FAIL #define BEAST_FAIL() ::boost::beast::unit_test::suite::this_suite()->fail("", __FILE__, __LINE__) #endif #ifndef BEAST_EXPECT /** Check a precondition. If the condition is false, the file and line number are reported. */ #define BEAST_EXPECT(cond) ::boost::beast::unit_test::suite::this_suite()->expect(cond, __FILE__, __LINE__) #endif #ifndef BEAST_EXPECTS /** Check a precondition. If the condition is false, the file and line number are reported. */ #define BEAST_EXPECTS(cond, reason) ((cond) ? \ (::boost::beast::unit_test::suite::this_suite()->pass(), true) : \ (::boost::beast::unit_test::suite::this_suite()->fail((reason), __FILE__, __LINE__), false)) #endif /** Ensure an exception is thrown */ #define BEAST_THROWS( EXPR, EXCEP ) \ try { \ EXPR; \ BEAST_FAIL(); \ } \ catch(EXCEP const&) { \ BEAST_PASS(); \ } \ catch(...) { \ BEAST_FAIL(); \ } } // unit_test } // beast } // boost //------------------------------------------------------------------------------ // detail: // This inserts the suite with the given manual flag #define BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,manual) \ static ::boost::beast::unit_test::detail::insert_suite <Class##_test> \ Library ## Module ## Class ## _test_instance( \ #Class, #Module, #Library, manual) //------------------------------------------------------------------------------ // Preprocessor directives for controlling unit test definitions. // If this is already defined, don't redefine it. This allows // programs to provide custom behavior for testsuite definitions // #ifndef BEAST_DEFINE_TESTSUITE /** Enables insertion of test suites into the global container. The default is to insert all test suite definitions into the global container. If BEAST_DEFINE_TESTSUITE is user defined, this macro has no effect. */ #ifndef BEAST_NO_UNIT_TEST_INLINE #define BEAST_NO_UNIT_TEST_INLINE 0 #endif /** Define a unit test suite. Library Identifies the library. Module Identifies the module. Class The type representing the class being tested. The declaration for the class implementing the test should be the same as Class ## _test. For example, if Class is aged_ordered_container, the test class must be declared as: @code struct aged_ordered_container_test : beast::unit_test::suite { //... }; @endcode The macro invocation must appear in the same namespace as the test class. */ #if BEAST_NO_UNIT_TEST_INLINE #define BEAST_DEFINE_TESTSUITE(Class,Module,Library) #else #include <boost/beast/_experimental/unit_test/global_suites.hpp> #define BEAST_DEFINE_TESTSUITE(Library,Module,Class) \ BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,false) #define BEAST_DEFINE_TESTSUITE_MANUAL(Library,Module,Class) \ BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,true) #endif #endif //------------------------------------------------------------------------------ #endif