Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

AssertionResultBuilder -> ExpressionResultBuilder

Commit
f847186ebbf0e7eeabd99925574c8988add600fb
Author
Phil Nash ·
Parents
8cca2f13699a

Files · Download .tar.gz

Changes

 include/internal/catch_capture.hpp                 | 44 ++++++++++----------
 include/internal/catch_expression_decomposer.hpp   |  1 -
 include/internal/catch_expression_lhs.hpp          | 47 ++++++++++++----------
 ..._builder.h => catch_expressionresult_builder.h} | 30 +++++---------
 ...lder.hpp => catch_expressionresult_builder.hpp} | 30 +++++++-------
 include/internal/catch_impl.hpp                    |  2 +-
 include/internal/catch_interfaces_capture.h        |  4 +-
 include/internal/catch_runner_impl.hpp             |  6 +--
 .../CatchSelfTest.xcodeproj/project.pbxproj        |  8 ++--
 9 files changed, 83 insertions(+), 89 deletions(-)

diff --git a/include/internal/catch_capture.hpp b/include/internal/catch_capture.hpp
index 73ecc425..e724cd43 100644
--- a/include/internal/catch_capture.hpp
+++ b/include/internal/catch_capture.hpp
@@ -9,7 +9,7 @@
 #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
 
 #include "catch_expression_decomposer.hpp"
-#include "catch_assertionresult_builder.h"
+#include "catch_expressionresult_builder.h"
 #include "catch_interfaces_capture.h"
 #include "catch_debugger.hpp"
 #include "catch_context.h"
@@ -24,30 +24,30 @@ namespace Catch {
     }
     
     template<typename MatcherT>
-    AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
-                                                        const std::string& matcherCallAsString ) {
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
+                                                                const std::string& matcherCallAsString ) {
         std::string matcherAsString = matcher.toString();
         if( matcherAsString == "{?}" )
             matcherAsString = matcherCallAsString;
-        return AssertionResultBuilder()
+        return ExpressionResultBuilder()
             .setRhs( matcherAsString )
             .setOp( "matches" );
     }
 
     template<typename MatcherT, typename ArgT>
-    AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
-                                                        const ArgT& arg,
-                                                        const std::string& matcherCallAsString ) {
-        return assertionBuilderFromMatcher( matcher, matcherCallAsString )
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
+                                                                const ArgT& arg,
+                                                                const std::string& matcherCallAsString ) {
+        return expressionResultBuilderFromMatcher( matcher, matcherCallAsString )
             .setLhs( Catch::toString( arg ) )
             .setResultType( matcher.match( arg ) );
     }
 
     template<typename MatcherT, typename ArgT>
-    AssertionResultBuilder assertionBuilderFromMatcher( const MatcherT& matcher,
-                                                        ArgT* arg,
-                                                        const std::string& matcherCallAsString ) {
-        return assertionBuilderFromMatcher( matcher, matcherCallAsString )
+    ExpressionResultBuilder expressionResultBuilderFromMatcher( const MatcherT& matcher,
+                                                                ArgT* arg,
+                                                                const std::string& matcherCallAsString ) {
+        return expressionResultBuilderFromMatcher( matcher, matcherCallAsString )
             .setLhs( Catch::toString( arg ) )
             .setResultType( matcher.match( arg ) );
     }
@@ -72,7 +72,7 @@ public:
     }
     
 private:
-    AssertionResultBuilder m_resultBuilder;
+    ExpressionResultBuilder m_resultBuilder;
 };
         
 // This is just here to avoid compiler warnings with macro constants and boolean literals
@@ -101,7 +101,7 @@ inline bool isTrue( bool value ){ return value; }
     } catch( Catch::TestFailureException& ) { \
         throw; \
     } catch( ... ) { \
-        INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), false, expr ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), false, expr ); \
         throw; \
     } } while( Catch::isTrue( false ) )
 
@@ -120,10 +120,10 @@ inline bool isTrue( bool value ){ return value; }
     try { \
         INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, false ); \
         expr; \
-        INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \
     } \
     catch( ... ) { \
-        INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), stopOnFailure, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), stopOnFailure, false ); \
     }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -132,26 +132,26 @@ inline bool isTrue( bool value ){ return value; }
         INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, false ); \
         if( Catch::getCurrentContext().getConfig()->allowThrows() ) { \
             expr; \
-            INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \
+            INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::DidntThrowException ), stopOnFailure, false ); \
         } \
     } \
     catch( Catch::TestFailureException& ) { \
         throw; \
     } \
     catch( exceptionType ) { \
-        INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), stopOnFailure, false ); \
     }
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, stopOnFailure, macroName ) \
     INTERNAL_CATCH_THROWS( expr, exceptionType, stopOnFailure, macroName ) \
     catch( ... ) { \
-        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::AssertionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), stopOnFailure, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), stopOnFailure, false ); \
     }
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_MSG( reason, resultType, stopOnFailure, macroName ) \
-    INTERNAL_CATCH_ACCEPT_EXPR( Catch::AssertionResultBuilder( resultType ) << reason, stopOnFailure, true );
+    INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( resultType ) << reason, stopOnFailure, true );
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_SCOPED_INFO( log, macroName ) \
@@ -163,11 +163,11 @@ inline bool isTrue( bool value ){ return value; }
 #define INTERNAL_CHECK_THAT( arg, matcher, stopOnFailure, macroName ) \
     do { try { \
         INTERNAL_CATCH_ACCEPT_INFO( #arg " " #matcher, macroName, false ) \
-        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::assertionBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::expressionResultBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), stopOnFailure, false ); \
     } catch( Catch::TestFailureException& ) { \
         throw; \
     } catch( ... ) { \
-        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::AssertionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), false, false ); \
+        INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), false, false ); \
         throw; \
     }}while( Catch::isTrue( false ) )
 
diff --git a/include/internal/catch_expression_decomposer.hpp b/include/internal/catch_expression_decomposer.hpp
index 9dbd9833..3df9c25e 100644
--- a/include/internal/catch_expression_decomposer.hpp
+++ b/include/internal/catch_expression_decomposer.hpp
@@ -9,7 +9,6 @@
 #define TWOBLUECUBES_CATCH_EXPRESSION_DECOMPOSER_HPP_INCLUDED
 
 #include "catch_expression_lhs.hpp"
-#include "catch_assertionresult_builder.h"
 
 namespace Catch {
     
diff --git a/include/internal/catch_expression_lhs.hpp b/include/internal/catch_expression_lhs.hpp
index 7d2cc733..d85579d1 100644
--- a/include/internal/catch_expression_lhs.hpp
+++ b/include/internal/catch_expression_lhs.hpp
@@ -5,17 +5,19 @@
  *  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)
  */
-#ifndef TWOBLUECUBES_CATCH_EXPRESSION_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_EXPRESSION_HPP_INCLUDED
+#ifndef TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
 
-#include "catch_assertionresult_builder.h"
+#include "catch_expressionresult_builder.h"
 #include "catch_evaluate.hpp"
 
 namespace Catch {
 
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
     template<typename T>
-    inline void setResultIfBoolean( AssertionResultBuilder&, const T& ) {}
-    inline void setResultIfBoolean( AssertionResultBuilder& result, bool value ) {
+    inline void setResultIfBoolean( ExpressionResultBuilder&, const T& ) {}
+    inline void setResultIfBoolean( ExpressionResultBuilder& result, bool value ) {
         result.setResultType( value );
     }
 template<typename T>
@@ -28,56 +30,57 @@ public:
     }
 
     template<typename RhsT>
-    AssertionResultBuilder& operator == ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator == ( const RhsT& rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
     template<typename RhsT>
-    AssertionResultBuilder& operator != ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator != ( const RhsT& rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
     
     template<typename RhsT>
-    AssertionResultBuilder& operator < ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator < ( const RhsT& rhs ) {
         return captureExpression<Internal::IsLessThan>( rhs );
     }
     
     template<typename RhsT>
-    AssertionResultBuilder& operator > ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator > ( const RhsT& rhs ) {
         return captureExpression<Internal::IsGreaterThan>( rhs );
     }
     
     template<typename RhsT>
-    AssertionResultBuilder& operator <= ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator <= ( const RhsT& rhs ) {
         return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
     }
     
     template<typename RhsT>
-    AssertionResultBuilder& operator >= ( const RhsT& rhs ) {
+    ExpressionResultBuilder& operator >= ( const RhsT& rhs ) {
         return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
     }
 
-    AssertionResultBuilder& operator == ( bool rhs ) {
+    ExpressionResultBuilder& operator == ( bool rhs ) {
         return captureExpression<Internal::IsEqualTo>( rhs );
     }
     
-    AssertionResultBuilder& operator != ( bool rhs ) {
+    ExpressionResultBuilder& operator != ( bool rhs ) {
         return captureExpression<Internal::IsNotEqualTo>( rhs );
     }
     
-    AssertionResultBuilder negate( bool shouldNegate ) {
+    ExpressionResultBuilder negate( bool shouldNegate ) {
         return m_result.negate( shouldNegate );
     }
 
-    template<typename RhsT>
-    STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( const RhsT& );
-    
-    template<typename RhsT>
-    STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( const RhsT& );
+    // Only simple binary expressions are allowed on the LHS.
+    // If more complex compositions are required then place the sub expression in parentheses
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( const RhsT& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( const RhsT& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( const RhsT& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( const RhsT& );
 
 private:
     template<Internal::Operator Op, typename RhsT>
-    AssertionResultBuilder& captureExpression( const RhsT& rhs ) {
+    ExpressionResultBuilder& captureExpression( const RhsT& rhs ) {
         return m_result
             .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
             .setRhs( Catch::toString( rhs ) )
@@ -85,10 +88,10 @@ private:
     }
 
 private:
-    AssertionResultBuilder m_result;
+    ExpressionResultBuilder m_result;
     T m_lhs;
 };
 
 } // end namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_EXPRESSION_HPP_INCLUDED
+#endif // TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
diff --git a/include/internal/catch_assertionresult_builder.h b/include/internal/catch_expressionresult_builder.h
similarity index 50%
rename from include/internal/catch_assertionresult_builder.h
rename to include/internal/catch_expressionresult_builder.h
index fa53c25a..5c63b3ee 100644
--- a/include/internal/catch_assertionresult_builder.h
+++ b/include/internal/catch_expressionresult_builder.h
@@ -15,26 +15,24 @@
 #include "catch_common.h"
 
 namespace Catch {
-
-struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
     
-class AssertionResultBuilder {
+class ExpressionResultBuilder {
 public:
     
-    AssertionResultBuilder( ResultWas::OfType resultType = ResultWas::Unknown );
-    AssertionResultBuilder( const AssertionResultBuilder& other );
-    AssertionResultBuilder& operator=(const AssertionResultBuilder& other );
+    ExpressionResultBuilder( ResultWas::OfType resultType = ResultWas::Unknown );
+    ExpressionResultBuilder( const ExpressionResultBuilder& other );
+    ExpressionResultBuilder& operator=(const ExpressionResultBuilder& other );
 
-    AssertionResultBuilder& setResultType( ResultWas::OfType result );
-    AssertionResultBuilder& setResultType( bool result );
-    AssertionResultBuilder& setLhs( const std::string& lhs );
-    AssertionResultBuilder& setRhs( const std::string& rhs );
-    AssertionResultBuilder& setOp( const std::string& op );
+    ExpressionResultBuilder& setResultType( ResultWas::OfType result );
+    ExpressionResultBuilder& setResultType( bool result );
+    ExpressionResultBuilder& setLhs( const std::string& lhs );
+    ExpressionResultBuilder& setRhs( const std::string& rhs );
+    ExpressionResultBuilder& setOp( const std::string& op );
 
-    AssertionResultBuilder& negate( bool shouldNegate );
+    ExpressionResultBuilder& negate( bool shouldNegate );
 
     template<typename T>
-    AssertionResultBuilder& operator << ( const T& value ) {
+    ExpressionResultBuilder& operator << ( const T& value ) {
         m_stream << value;
         return *this;
     }
@@ -43,12 +41,6 @@ public:
 
     AssertionResultData build( const AssertionInfo& info ) const;
 
-    // Disable attempts to use || and && in expressions (without parantheses)
-    template<typename RhsT>
-    STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( const RhsT& );
-    template<typename RhsT>
-    STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( const RhsT& );
-
 private:
     AssertionResultData m_data;
     struct ExprComponents {
diff --git a/include/internal/catch_assertionresult_builder.hpp b/include/internal/catch_expressionresult_builder.hpp
similarity index 71%
rename from include/internal/catch_assertionresult_builder.hpp
rename to include/internal/catch_expressionresult_builder.hpp
index 2b03036f..ecaeddf6 100644
--- a/include/internal/catch_assertionresult_builder.hpp
+++ b/include/internal/catch_expressionresult_builder.hpp
@@ -5,56 +5,56 @@
  *  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)
  */
-#ifndef TWOBLUECUBES_CATCH_ASSERTIONRESULT_BUILDER_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_BUILDER_HPP_INCLUDED
+#ifndef TWOBLUECUBES_CATCH_EXPRESSIONRESULT_BUILDER_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_EXPRESSIONRESULT_BUILDER_HPP_INCLUDED
 
-#include "catch_assertionresult_builder.h"
+#include "catch_expressionresult_builder.h"
 
 #include <assert.h>
 
 namespace Catch {
 
-    AssertionResultBuilder::AssertionResultBuilder( ResultWas::OfType resultType ) {
+    ExpressionResultBuilder::ExpressionResultBuilder( ResultWas::OfType resultType ) {
         m_data.resultType = resultType;
     }
-    AssertionResultBuilder::AssertionResultBuilder( const AssertionResultBuilder& other )
+    ExpressionResultBuilder::ExpressionResultBuilder( const ExpressionResultBuilder& other )
     :   m_data( other.m_data ),
         m_exprComponents( other.m_exprComponents )
     {
         m_stream << other.m_stream.str();
     }
-    AssertionResultBuilder& AssertionResultBuilder::operator=(const AssertionResultBuilder& other ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::operator=(const ExpressionResultBuilder& other ) {
         m_data = other.m_data;
         m_exprComponents = other.m_exprComponents;
         m_stream.clear();
         m_stream << other.m_stream.str();
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::setResultType( ResultWas::OfType result ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setResultType( ResultWas::OfType result ) {
         m_data.resultType = result;
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::setResultType( bool result ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setResultType( bool result ) {
         m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::negate( bool shouldNegate ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::negate( bool shouldNegate ) {
         m_exprComponents.shouldNegate = shouldNegate;
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::setLhs( const std::string& lhs ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setLhs( const std::string& lhs ) {
         m_exprComponents.lhs = lhs;
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::setRhs( const std::string& rhs ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setRhs( const std::string& rhs ) {
         m_exprComponents.rhs = rhs;
         return *this;
     }
-    AssertionResultBuilder& AssertionResultBuilder::setOp( const std::string& op ) {
+    ExpressionResultBuilder& ExpressionResultBuilder::setOp( const std::string& op ) {
         m_exprComponents.op = op;
         return *this;
     }
-    AssertionResultData AssertionResultBuilder::build( const AssertionInfo& info ) const
+    AssertionResultData ExpressionResultBuilder::build( const AssertionInfo& info ) const
     {
         assert( m_data.resultType != ResultWas::Unknown );
 
@@ -76,7 +76,7 @@ namespace Catch {
         }
         return data;
     }
-    std::string AssertionResultBuilder::reconstructExpression( const AssertionInfo& info ) const {
+    std::string ExpressionResultBuilder::reconstructExpression( const AssertionInfo& info ) const {
         if( m_exprComponents.op == "" )
             return m_exprComponents.lhs.empty() ? info.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
         else if( m_exprComponents.op == "matches" )
@@ -95,4 +95,4 @@ namespace Catch {
 
 } // end namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_ASSERTIONRESULT_BUILDER_HPP_INCLUDED
+#endif // TWOBLUECUBES_CATCH_EXPRESSIONRESULT_BUILDER_HPP_INCLUDED
diff --git a/include/internal/catch_impl.hpp b/include/internal/catch_impl.hpp
index 64099b5d..8bbae1c1 100644
--- a/include/internal/catch_impl.hpp
+++ b/include/internal/catch_impl.hpp
@@ -23,7 +23,7 @@
 #include "catch_console_colour_impl.hpp"
 #include "catch_generators_impl.hpp"
 #include "catch_assertionresult.hpp"
-#include "catch_assertionresult_builder.hpp"
+#include "catch_expressionresult_builder.hpp"
 #include "catch_test_case_info.hpp"
 #include "catch_tags.hpp"
 
diff --git a/include/internal/catch_interfaces_capture.h b/include/internal/catch_interfaces_capture.h
index 56790cb4..db5765ca 100644
--- a/include/internal/catch_interfaces_capture.h
+++ b/include/internal/catch_interfaces_capture.h
@@ -17,7 +17,7 @@ namespace Catch {
 
     class TestCaseInfo;
     class ScopedInfo;
-    class AssertionResultBuilder;
+    class ExpressionResultBuilder;
     class AssertionResult;
     struct AssertionInfo;
 
@@ -36,7 +36,7 @@ namespace Catch {
         virtual bool shouldDebugBreak() const = 0;
         
         virtual void acceptAssertionInfo( const AssertionInfo& assertionInfo ) = 0;
-        virtual ResultAction::Value acceptExpression( const AssertionResultBuilder& assertionResult ) = 0;
+        virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult ) = 0;
         
         virtual std::string getCurrentTestName() const = 0;        
         virtual const AssertionResult* getLastResult() const = 0;        
diff --git a/include/internal/catch_runner_impl.hpp b/include/internal/catch_runner_impl.hpp
index 603aeb0d..489bc5d7 100644
--- a/include/internal/catch_runner_impl.hpp
+++ b/include/internal/catch_runner_impl.hpp
@@ -135,7 +135,7 @@ namespace Catch {
             m_assertionInfo = assertionInfo;
         }
         
-        virtual ResultAction::Value acceptExpression( const AssertionResultBuilder& assertionResult ) {
+        virtual ResultAction::Value acceptExpression( const ExpressionResultBuilder& assertionResult ) {
             m_currentResult = assertionResult;
             return actOnCurrentResult();
         }
@@ -236,7 +236,7 @@ namespace Catch {
             m_lastResult = AssertionResult( m_assertionInfo, m_currentResult.build( m_assertionInfo ) );
             testEnded( m_lastResult );
 
-            m_currentResult = AssertionResultBuilder();
+            m_currentResult = ExpressionResultBuilder();
             m_assertionInfo = AssertionInfo();
 
             ResultAction::Value action = ResultAction::None;
@@ -287,7 +287,7 @@ namespace Catch {
     private:
         IMutableContext& m_context;
         RunningTest* m_runningTest;
-        AssertionResultBuilder m_currentResult;
+        ExpressionResultBuilder m_currentResult;
         AssertionResult m_lastResult;
 
         const Config& m_config;
diff --git a/projects/XCode4/CatchSelfTest/CatchSelfTest.xcodeproj/project.pbxproj b/projects/XCode4/CatchSelfTest/CatchSelfTest.xcodeproj/project.pbxproj
index 68507bd1..168b721b 100644
--- a/projects/XCode4/CatchSelfTest/CatchSelfTest.xcodeproj/project.pbxproj
+++ b/projects/XCode4/CatchSelfTest/CatchSelfTest.xcodeproj/project.pbxproj
@@ -121,9 +121,9 @@
 		4A8E4DD0160A352200194CBD /* catch_tags.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = catch_tags.cpp; path = ../../../SelfTest/SurrogateCpps/catch_tags.cpp; sourceTree = "<group>"; };
 		4A90B59B15D0F61A00EF71BC /* catch_interfaces_generators.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = catch_interfaces_generators.h; sourceTree = "<group>"; };
 		4A90B59D15D24FE900EF71BC /* catch_assertionresult.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = catch_assertionresult.hpp; sourceTree = "<group>"; };
-		4A90B59E15D2521E00EF71BC /* catch_assertionresult_builder.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; lineEnding = 0; path = catch_assertionresult_builder.hpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
+		4A90B59E15D2521E00EF71BC /* catch_expressionresult_builder.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; lineEnding = 0; path = catch_expressionresult_builder.hpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
 		4A9D84B11558FC0400FBB209 /* catch_tostring.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = catch_tostring.hpp; sourceTree = "<group>"; };
-		4A9D84B315599AC900FBB209 /* catch_assertionresult_builder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = catch_assertionresult_builder.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		4A9D84B315599AC900FBB209 /* catch_expressionresult_builder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = catch_expressionresult_builder.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
 		4AA7FF4115F3E89D009AD7F9 /* BDDTests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BDDTests.cpp; sourceTree = "<group>"; };
 		4AB1C73514F97BDA00F31DF7 /* catch_console_colour_impl.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = catch_console_colour_impl.hpp; sourceTree = "<group>"; };
 		4AB1C73714F97C1300F31DF7 /* catch_console_colour.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = catch_console_colour.hpp; sourceTree = "<group>"; };
@@ -276,7 +276,7 @@
 				4AB1C73514F97BDA00F31DF7 /* catch_console_colour_impl.hpp */,
 				4A4B0F9B15CEF8C400AE2392 /* catch_notimplemented_exception.hpp */,
 				4A90B59D15D24FE900EF71BC /* catch_assertionresult.hpp */,
-				4A90B59E15D2521E00EF71BC /* catch_assertionresult_builder.hpp */,
+				4A90B59E15D2521E00EF71BC /* catch_expressionresult_builder.hpp */,
 				4A084F1C15DACEEA0027E631 /* catch_test_case_info.hpp */,
 			);
 			name = impl;
@@ -289,7 +289,7 @@
 				4A6D0C4F149B3E3D00DB3EAA /* catch_generators.hpp */,
 				4A6D0C5C149B3E3D00DB3EAA /* catch_result_type.h */,
 				4A6D0C5D149B3E3D00DB3EAA /* catch_assertionresult.h */,
-				4A9D84B315599AC900FBB209 /* catch_assertionresult_builder.h */,
+				4A9D84B315599AC900FBB209 /* catch_expressionresult_builder.h */,
 				4A6D0C5F149B3E3D00DB3EAA /* catch_section.hpp */,
 				4A3D7DD01503869D005F9203 /* catch_matchers.hpp */,
 				4A9D84B11558FC0400FBB209 /* catch_tostring.hpp */,