Completed NoAssertions warning implementation

include/catch.hpp

@@ -113,6 +113,7 @@
 #define INFO( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Info, false, "INFO" )
 #define WARN( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Warning, false, "WARN" )
 #define FAIL( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::ExplicitFailure, true, "FAIL" )
+#define SUCCEED( msg ) INTERNAL_CATCH_MSG( msg, Catch::ResultWas::Ok, false, "SUCCEED" )
 #define SCOPED_INFO( msg ) INTERNAL_CATCH_SCOPED_INFO( msg )
 #define CAPTURE( msg ) INTERNAL_CATCH_MSG( #msg " := " << msg, Catch::ResultWas::Info, false, "CAPTURE" )
 

include/internal/catch_config.hpp

@@ -149,6 +149,9 @@ namespace Catch {
             return m_data.allowThrows;
         }
         
+        const ConfigData& data() const {
+            return m_data;
+        }
         ConfigData& data() {
             return m_data;
         }

include/internal/catch_interfaces_reporter.h

@@ -48,6 +48,8 @@ namespace Catch
         virtual void StartGroup( const std::string& groupName ) = 0;        
         virtual void EndGroup( const std::string& groupName, const Totals& totals ) = 0;        
         virtual void StartSection( const std::string& sectionName, const std::string& description ) = 0;
+        virtual void NoAssertionsInSection( const std::string& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( const std::string& testName ) = 0;
         virtual void EndSection( const std::string& sectionName, const Counts& assertions ) = 0;
         virtual void StartTestCase( const TestCaseInfo& testInfo ) = 0;        
         virtual void Aborted() = 0;

include/internal/catch_runner_impl.hpp

@@ -190,8 +190,16 @@ namespace Catch {
         }
         
         virtual void sectionEnded( const std::string& name, const Counts& prevAssertions ) {
+            Counts assertions = m_totals.assertions - prevAssertions;
+            if( assertions.total() == 0  &&
+               ( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
+               !m_runningTest->isBranchSection() ) {
+                m_reporter->NoAssertionsInSection( name );
+                m_totals.assertions.failed++;
+                assertions.failed++;
+            }
             m_runningTest->endSection( name );
-            m_reporter->EndSection( name, m_totals.assertions - prevAssertions );
+            m_reporter->EndSection( name, assertions );
         }
 
         virtual void pushScopedInfo( ScopedInfo* scopedInfo ) {
@@ -246,6 +254,7 @@ namespace Catch {
         void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
             try {
                 m_runningTest->reset();
+                Counts prevAssertions = m_totals.assertions;
                 if( m_reporter->shouldRedirectStdout() ) {
                     StreamRedirect coutRedir( std::cout, redirectedCout );
                     StreamRedirect cerrRedir( std::cerr, redirectedCerr );
@@ -254,6 +263,13 @@ namespace Catch {
                 else {
                     m_runningTest->getTestCaseInfo().invoke();
                 }
+                Counts assertions = m_totals.assertions - prevAssertions;
+                if( assertions.total() == 0  &&
+                   ( m_config.data().warnings & ConfigData::WarnAbout::NoAssertions ) &&
+                   !m_runningTest->hasSections() ) {
+                        m_totals.assertions.failed++;                        
+                        m_reporter->NoAssertionsInTestCase( m_runningTest->getTestCaseInfo().getName() );
+                }
                 m_runningTest->ranToCompletion();
             }
             catch( TestFailureException& ) {

include/internal/catch_running_test.hpp

@@ -36,6 +36,17 @@ namespace Catch {
                     m_runStatus == RanToCompletionWithSections;
         }
         
+        bool isBranchSection() const {
+            return  m_currentSection &&
+                    m_currentSection->isBranch();
+        }
+
+        bool hasSections() const {
+            return  m_runStatus == RanAtLeastOneSection ||
+                    m_runStatus == RanToCompletionWithSections ||
+                    m_runStatus == EncounteredASection;
+        }
+
         void reset() {
             m_runStatus = NothingRun;
             m_changed = false;

include/internal/catch_section_info.hpp

@@ -52,6 +52,10 @@ namespace Catch {
             return false;
         }
 
+        bool isBranch() const {
+            return m_status == Branch;
+        }
+
         void ranToCompletion() {
             if( m_status == Branch && !hasUntestedSections() )
                 m_status = TestedBranch;

include/reporters/catch_reporter_basic.hpp

@@ -128,11 +128,18 @@ namespace Catch {
             m_sectionSpans.push_back( SpanInfo( sectionName ) );
         }
 
+        virtual void NoAssertionsInSection( const std::string& sectionName ) {
+            StartSpansLazily();
+            TextColour colour( TextColour::ResultError );
+            m_config.stream << "\nNo assertions in section, '" << sectionName << "'\n" << std::endl;
+        }
+        virtual void NoAssertionsInTestCase( const std::string& testName ) {
+            StartSpansLazily();
+            TextColour colour( TextColour::ResultError );
+            m_config.stream << "\nNo assertions in test case, '" << testName << "'\n" << std::endl;
+        }
+
         virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
-            if( ( m_config.fullConfig.warnings & ConfigData::WarnAbout::NoAssertions ) && assertions.total() == 0 ) {
-                StartSpansLazily();
-                m_config.stream << "** No assertions in section **" << std::endl;
-            }
 
             SpanInfo& sectionSpan = m_sectionSpans.back();
             if( sectionSpan.emitted && !sectionSpan.name.empty() ) {

include/reporters/catch_reporter_junit.hpp

@@ -88,7 +88,10 @@ namespace Catch {
         
         virtual void StartSection( const std::string&, const std::string& ){}
 
-        virtual void EndSection( const std::string&, const Counts& ){}
+        virtual void NoAssertionsInSection( const std::string& ) {}
+        virtual void NoAssertionsInTestCase( const std::string& ) {}
+
+        virtual void EndSection( const std::string&, const Counts& ) {}
         
         virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
             m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getName() ) );            

include/reporters/catch_reporter_xml.hpp

@@ -60,6 +60,8 @@ namespace Catch {
                 .writeAttribute( "name", sectionName )
                 .writeAttribute( "description", description );
         }
+        virtual void NoAssertionsInSection( const std::string& ) {}
+        virtual void NoAssertionsInTestCase( const std::string& ) {}
 
         virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
             m_xml.scopedElement( "OverallResults" )

projects/SelfTest/MiscTests.cpp

@@ -289,3 +289,7 @@ TEST_CASE( "example/factorial", "The Factorial function should return the factor
   REQUIRE( Factorial(3) == 6 );
   REQUIRE( Factorial(10) == 3628800 );
 }
+
+TEST_CASE( "empty", "An empty test with no assertions" )
+{
+}

projects/SelfTest/catch_self_test.hpp

@@ -75,6 +75,9 @@ namespace Catch {
             openLabel( recordSections, sectionName );
         }
 
+        virtual void NoAssertionsInSection( const std::string& ) {}
+        virtual void NoAssertionsInTestCase( const std::string& ) {}
+
         virtual void EndSection( const std::string& sectionName, const Counts& ) {
             closeLabel( recordSections, sectionName );
         }
@@ -162,6 +165,9 @@ namespace Catch {
                              << "' to succeed but there was/ were " 
                              << totals.assertions.failed << " failure(s)" );
                     }
+                    else {
+                        SUCCEED( "Tests passed, as expected" );
+                    }
                     break;
                 case Expected::ToFail:
                     if( totals.assertions.passed > 0 ) {
@@ -171,6 +177,9 @@ namespace Catch {
                              << "' to fail but there was/ were " 
                              << totals.assertions.passed << " success(es)" );
                     }
+                    else {
+                        SUCCEED( "Tests failed, as expected" );
+                    }
                     break;
             }        
         };