Subject: [Boost-commit] svn:boost r74880 - trunk/boost/test/tools
From: gennadiy.rozental_at_[hidden]
Date: 2011-10-10 04:39:05
Author: rogeeff
Date: 2011-10-10 04:39:04 EDT (Mon, 10 Oct 2011)
New Revision: 74880
URL: http://svn.boost.org/trac/boost/changeset/74880
Log:
new framework for automated assertion construction
Added:
trunk/boost/test/tools/assertion.hpp (contents, props changed)
Added: trunk/boost/test/tools/assertion.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/test/tools/assertion.hpp 2011-10-10 04:39:04 EDT (Mon, 10 Oct 2011)
@@ -0,0 +1,372 @@
+// (C) Copyright Gennadiy Rozental 2011.
+// 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)
+
+// See http://www.boost.org/libs/test for the library home page.
+//
+// File : $RCSfile$
+//
+// Version : $Revision: 74663 $
+//
+// Description : defines framework for automated assertion construction
+// ***************************************************************************
+
+#ifndef BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
+#define BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
+
+// Boost.Test
+
+// Boost
+#include <boost/mpl/assert.hpp>
+#include <boost/utility/declval.hpp>
+
+#include <boost/test/detail/suppress_warnings.hpp>
+
+//____________________________________________________________________________//
+
+namespace boost {
+namespace test_tools {
+namespace assertion {
+
+// ************************************************************************** //
+// ************** assertion::expression ************** //
+// ************************************************************************** //
+
+class expression {
+public:
+ // expression interface
+ virtual predicate_result evaluate() const = 0;
+};
+
+// ************************************************************************** //
+// ************** assertion::operators ************** //
+// ************************************************************************** //
+
+namespace op {
+
+enum id {
+ // precedence 4: ->*, .*
+ MEMP,
+ // precedence 5: *, /, %
+ MUL, DIV, MOD,
+ // precedence 6: +, -
+ ADD, SUB,
+ // precedence 7: << , >>
+ LSH, RSH,
+ // precedence 8: <, <=, > and >=
+ LT, LE, GT, GE,
+ // precedence 9: == and !=
+ EQ, NE,
+ // precedence 10: bitwise AND
+ BAND,
+ // precedence 11: bitwise XOR
+ XOR,
+ // precedence 12: bitwise OR
+ BOR,
+ // precedence 13: logical AND
+ // disabled
+ // precedence 14: logical OR
+ // disabled
+ // precedence 15: ternary conditional
+ // disabled
+
+ // precedence 16: = and OP= operators
+ SET, IADD, ISUB, IMUL, IDIV, IMOD,
+ ILSH, IRSH,
+ IAND, IXOR, IOR
+ // precedence 17: throw operator
+ // not supported
+ // precedence 18: comma
+ // not supported
+};
+
+#define BOOST_TEST_FOR_EACH_OP( action ) \
+ action(->*, MEMP ) \
+ \
+ action( * , MUL ) \
+ action( / , DIV ) \
+ action( % , MOD ) \
+ \
+ action( + , ADD ) \
+ action( - , SUB ) \
+ \
+ action( <<, LSH ) \
+ action( >>, RSH ) \
+ \
+ action( < , LT ) \
+ action( <=, LE ) \
+ action( > , GT ) \
+ action( >=, GE ) \
+ \
+ action( ==, EQ ) \
+ action( !=, NE ) \
+ \
+ action( & , BAND ) \
+ action( ^ , XOR ) \
+ action( | , BOR ) \
+/**/
+
+#define BOOST_TEST_FOR_EACH_MUT_OP( action )\
+ action( = , SET ) \
+ action( +=, IADD ) \
+ action( -=, ISUB ) \
+ action( *=, IMUL ) \
+ action( /=, IDIV ) \
+ action( %=, IMOD ) \
+ action(<<=, ILSH ) \
+ action(>>=, IRSH ) \
+ action( &=, IAND ) \
+ action( ^=, IXOR ) \
+ action( |=, IOR ) \
+/**/
+
+// ************************************************************************** //
+// ************** assertion::operator traits ************** //
+// ************************************************************************** //
+
+template<id ID>
+struct traits {
+ static char const* reverse( char const* direct ) { return direct; }
+};
+
+template<> struct traits<EQ> { static char const* reverse( char const* ) { return "!="; } };
+template<> struct traits<NE> { static char const* reverse( char const* ) { return "=="; } };
+
+template<> struct traits<LT> { static char const* reverse( char const* ) { return ">="; } };
+template<> struct traits<LE> { static char const* reverse( char const* ) { return ">"; } };
+template<> struct traits<GT> { static char const* reverse( char const* ) { return "<="; } };
+template<> struct traits<GE> { static char const* reverse( char const* ) { return "<"; } };
+
+} // anmespace op
+
+// ************************************************************************** //
+// ************** assertion::expression_result ************** //
+// ************************************************************************** //
+
+namespace detail {
+
+template<typename PrevExprType,typename Rhs,op::id OP>
+class expression_result;
+
+#ifndef BOOST_NO_DECLTYPE
+
+#define DEFINE_OP_EXPRESSION_RESULT( OPER, ID ) \
+template<typename PrevExprType,typename Rhs> \
+class expression_result<PrevExprType,Rhs,op::ID> { \
+ typedef typename PrevExprType::result_type Lhs; \
+public: \
+ \
+ typedef decltype(boost::declval<Lhs>() OPER \
+ boost::declval<Rhs>() ) type; \
+ \
+ static type \
+ produce( Lhs const& lhs, Rhs const& rhs) \
+ { \
+ return lhs OPER rhs; \
+ } \
+ \
+ static void \
+ report( std::ostream& ostr, \
+ PrevExprType const& lhs, Rhs const& rhs) \
+ { \
+ lhs.report( ostr ); \
+ ostr << op::traits<op::ID>::reverse( #OPER ) \
+ << rhs; \
+ } \
+}; \
+/**/
+
+////////////////////////////////////////////////////////////////
+
+BOOST_TEST_FOR_EACH_OP( DEFINE_OP_EXPRESSION_RESULT );
+
+#undef DEFINE_OP_EXPRESSION_RESULT
+
+#endif
+
+} // namespace detail
+
+////////////////////////////////////////////////////////////////
+
+// ************************************************************************** //
+// ************** assertion::expression_op ************** //
+// ************************************************************************** //
+// Defines expression operators
+
+template<typename Lhs,typename Rhs,op::id OP> class binary_expr;
+
+template<typename ExprType>
+class expression_op {
+public:
+#ifndef BOOST_NO_DECLTYPE
+
+#define ADD_OP_SUPPORT( OPER, ID ) \
+ template<typename T> \
+ binary_expr<ExprType,T,op::ID> \
+ operator OPER( T const& rhs ) const \
+ { \
+ return binary_expr<ExprType,T,op::ID>( \
+ *static_cast<ExprType const*>(this), \
+ rhs ); \
+ } \
+/**/
+
+ BOOST_TEST_FOR_EACH_OP( ADD_OP_SUPPORT );
+#undef ADD_OP_SUPPORT
+
+#endif
+
+ // Disabled operators
+ template<typename T>
+ ExprType&
+ operator ||( T const& rhs )
+ {
+ BOOST_MPL_ASSERT_MSG(false, CANT_USE_LOGICAL_OPERATOR_OR_WITHIN_THIS_TESTING_TOOL, () );
+
+ return *static_cast<ExprType*>(this);
+ }
+
+ template<typename T>
+ ExprType&
+ operator &&( T const& rhs )
+ {
+ BOOST_MPL_ASSERT_MSG(false, CANT_USE_LOGICAL_OPERATOR_AND_WITHIN_THIS_TESTING_TOOL, () );
+
+ return *static_cast<ExprType*>(this);
+ }
+
+ operator bool()
+ {
+ BOOST_MPL_ASSERT_MSG(false, CANT_USE_TERNARY_OPERATOR_WITHIN_THIS_TESTING_TOOL, () );
+
+ return false;
+ }
+};
+
+// ************************************************************************** //
+// ************** assertion::value_expr ************** //
+// ************************************************************************** //
+// simple value expression
+
+template<typename T>
+class value_expr : public expression, public expression_op<value_expr<T> > {
+public:
+ // Public types
+ typedef T result_type;
+
+ // Constructor
+ explicit value_expr( T&& val )
+ : m_value( val )
+ {}
+
+ // Specific expresson interface
+ T const& value() const
+ {
+ return m_value;
+ }
+ void report( std::ostream& ostr ) const
+ {
+ ostr << m_value;
+ }
+
+ // Mutating operators
+#define ADD_OP_SUPPORT( OPER, ID ) \
+ template<typename U> \
+ value_expr<T>& \
+ operator OPER( U const& rhs ) \
+ { \
+ m_value OPER rhs; \
+ \
+ return *this; \
+ } \
+/**/
+
+ BOOST_TEST_FOR_EACH_MUT_OP( ADD_OP_SUPPORT )
+#undef ADD_OP_SUPPORT
+
+private:
+ // expression interface
+ virtual predicate_result evaluate() const
+ {
+ predicate_result res( value() );
+ if( !res )
+ res.message() << "(bool)" << value() << " is false";
+
+ return res;
+ }
+
+ // Data members
+ T m_value;
+};
+
+// ************************************************************************** //
+// ************** assertion::binary_expr_expr ************** //
+// ************************************************************************** //
+// binary expression
+
+template<typename Lhs,typename Rhs,op::id OP>
+class binary_expr : public expression, public expression_op<binary_expr<Lhs,Rhs,OP> > {
+ typedef detail::expression_result<Lhs,Rhs,OP> result;
+public:
+ // Public types
+ typedef typename result::type result_type;
+
+ // Constructor
+ binary_expr( Lhs const& lhs, Rhs const& rhs )
+ : m_lhs( lhs )
+ , m_rhs( rhs )
+ {}
+
+ // Specifica expression interface
+ result_type value() const
+ {
+ return result::produce( m_lhs.value(), m_rhs );
+ }
+ void report( std::ostream& ostr ) const
+ {
+ return result::report( ostr, m_lhs, m_rhs );
+ }
+
+private:
+ // expression interface
+ virtual predicate_result evaluate() const
+ {
+ predicate_result res( value() );
+ if( !res )
+ report( res.message().stream() );
+
+ return res;
+ }
+
+ // Data members
+ Lhs m_lhs;
+ Rhs m_rhs;
+};
+
+// ************************************************************************** //
+// ************** assertion::seed ************** //
+// ************************************************************************** //
+// seed added ot the input expression to form an assertion expression
+
+class seed {
+public:
+ // ->* is highest precedence left to right operator
+ template<typename T>
+ value_expr<T>
+ operator->*( T&& v )
+ {
+ return value_expr<T>( std::forward<T>( v ) );
+ }
+};
+
+#undef BOOST_TEST_FOR_EACH_OP
+
+} // namespace assertion
+} // namespace test_tools
+} // namespace boost
+
+#include <boost/test/detail/enable_warnings.hpp>
+
+#endif // BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
+