3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-26 07:16:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fixed section ordering issue

Browse Source 
If a branch section completes without running any inner sections it will no run subsequent sections (until the next isolated run).
This commit is contained in:
Phil Nash 2012-05-05 19:32:52 +01:00
parent b213202ad7
commit a976c07b8d
7 changed files with 356 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

232
include/internal/catch_runner_impl.hpp
View File

@ -19,6 +19,7 @@
#include "catch_test_case_info.hpp"
#include "catch_capture.hpp"
#include "catch_totals.hpp"
#include "catch_running_test.hpp"
#include <set>
#include <string>
@ -57,237 +58,6 @@ namespace Catch
std::string& m_targetString;
};
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class SectionInfo
{
public:
enum Status
{
Root,
Unknown,
NonLeaf,
TestedLeaf
};
///////////////////////////////////////////////////////////////////////
SectionInfo
(
SectionInfo* parent
)
: m_status( Unknown ),
m_parent( parent )
{
}
///////////////////////////////////////////////////////////////////////
SectionInfo
()
: m_status( Root ),
m_parent( NULL )
{
}
///////////////////////////////////////////////////////////////////////
~SectionInfo
()
{
deleteAllValues( m_subSections );
}
///////////////////////////////////////////////////////////////////////
bool shouldRun
()
const
{
return m_status != TestedLeaf;
}
///////////////////////////////////////////////////////////////////////
bool ran
()
{
if( m_status != NonLeaf )
{
m_status = TestedLeaf;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* findSubSection
(
const std::string& name
)
{
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.find( name );
return it != m_subSections.end()
? it->second
: NULL;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* addSubSection
(
const std::string& name
)
{
SectionInfo* subSection = new SectionInfo( this );
m_subSections.insert( std::make_pair( name, subSection ) );
m_status = NonLeaf;
return subSection;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* getParent
()
{
return m_parent;
}
///////////////////////////////////////////////////////////////////////
bool hasUntestedSections
()
const
{
if( m_status == Unknown )
return true;
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.begin();
std::map<std::string, SectionInfo*>::const_iterator itEnd = m_subSections.end();
for(; it != itEnd; ++it )
{
if( it->second->hasUntestedSections() )
return true;
}
return false;
}
private:
Status m_status;
std::map<std::string, SectionInfo*> m_subSections;
SectionInfo* m_parent;
};
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class RunningTest
{
enum RunStatus
{
NothingRun,
EncounteredASection,
RanAtLeastOneSection,
RanToCompletionWithSections,
RanToCompletionWithNoSections
};
public:
///////////////////////////////////////////////////////////////////////
explicit RunningTest
(
const TestCaseInfo* info = NULL
)
: m_info( info ),
m_runStatus( RanAtLeastOneSection ),
m_currentSection( &m_rootSection ),
m_changed( false )
{
}
///////////////////////////////////////////////////////////////////////
bool wasSectionSeen
()
const
{
return m_runStatus == RanAtLeastOneSection ||
m_runStatus == RanToCompletionWithSections;
}
///////////////////////////////////////////////////////////////////////
void reset
()
{
m_runStatus = NothingRun;
m_changed = false;
}
///////////////////////////////////////////////////////////////////////
void ranToCompletion
()
{
m_runStatus = m_runStatus == RanAtLeastOneSection ||
m_runStatus == EncounteredASection
? RanToCompletionWithSections
: RanToCompletionWithNoSections;
}
///////////////////////////////////////////////////////////////////////
bool addSection
(
const std::string& name
)
{
if( m_runStatus == NothingRun )
m_runStatus = EncounteredASection;
SectionInfo* thisSection = m_currentSection->findSubSection( name );
if( !thisSection )
{
thisSection = m_currentSection->addSubSection( name );
m_changed = true;
}
if( !wasSectionSeen() && thisSection->shouldRun() )
{
m_currentSection = thisSection;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
void endSection
(
const std::string&
)
{
if( m_currentSection->ran() )
{
m_runStatus = RanAtLeastOneSection;
m_changed = true;
}
m_currentSection = m_currentSection->getParent();
}
///////////////////////////////////////////////////////////////////////
const TestCaseInfo& getTestCaseInfo
()
const
{
return *m_info;
}
///////////////////////////////////////////////////////////////////////
bool hasUntestedSections
()
const
{
return m_runStatus == RanAtLeastOneSection ||
( m_rootSection.hasUntestedSections() && m_changed );
}
private:
const TestCaseInfo* m_info;
RunStatus m_runStatus;
SectionInfo m_rootSection;
SectionInfo* m_currentSection;
bool m_changed;
};
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class Runner : public IResultCapture, public IRunner

150
include/internal/catch_running_test.hpp Normal file
View File

@ -0,0 +1,150 @@
/*
* Created by Phil Nash on 4/5/2012
* Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
*
* 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_INTERNAL_CATCH_RUNNING_TEST_HPP_INCLUDED
#define TWOBLUECUBES_INTERNAL_CATCH_RUNNING_TEST_HPP_INCLUDED
#include "catch_test_case_info.hpp"
#include "catch_section_info.hpp"
namespace Catch
{
class RunningTest
{
enum RunStatus
{
NothingRun,
EncounteredASection,
RanAtLeastOneSection,
RanToCompletionWithSections,
RanToCompletionWithNoSections
};
public:
///////////////////////////////////////////////////////////////////////
explicit RunningTest
(
const TestCaseInfo* info = NULL
)
: m_info( info ),
m_runStatus( RanAtLeastOneSection ),
m_currentSection( &m_rootSection ),
m_changed( false )
{
}
///////////////////////////////////////////////////////////////////////
bool wasSectionSeen
()
const
{
return m_runStatus == RanAtLeastOneSection ||
m_runStatus == RanToCompletionWithSections;
}
///////////////////////////////////////////////////////////////////////
void reset
()
{
m_runStatus = NothingRun;
m_changed = false;
m_lastSectionToRun = NULL;
}
///////////////////////////////////////////////////////////////////////
void ranToCompletion
()
{
if( m_runStatus == RanAtLeastOneSection ||
m_runStatus == EncounteredASection )
{
m_runStatus = RanToCompletionWithSections;
if( m_lastSectionToRun )
{
m_lastSectionToRun->ranToCompletion();
m_changed = true;
}
}
else
{
m_runStatus = RanToCompletionWithNoSections;
}
}
///////////////////////////////////////////////////////////////////////
bool addSection
(
const std::string& name
)
{
if( m_runStatus == NothingRun )
m_runStatus = EncounteredASection;
SectionInfo* thisSection = m_currentSection->findSubSection( name );
if( !thisSection )
{
thisSection = m_currentSection->addSubSection( name );
m_changed = true;
}
if( !wasSectionSeen() && thisSection->shouldRun() )
{
m_currentSection = thisSection;
m_lastSectionToRun = NULL;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
void endSection
(
const std::string&
)
{
if( m_currentSection->ran() )
{
m_runStatus = RanAtLeastOneSection;
m_changed = true;
}
else if( m_runStatus == EncounteredASection )
{
m_runStatus = RanAtLeastOneSection;
m_lastSectionToRun = m_currentSection;
// m_changed = true;
}
m_currentSection = m_currentSection->getParent();
}
///////////////////////////////////////////////////////////////////////
const TestCaseInfo& getTestCaseInfo
()
const
{
return *m_info;
}
///////////////////////////////////////////////////////////////////////
bool hasUntestedSections
()
const
{
return m_runStatus == RanAtLeastOneSection ||
( m_rootSection.hasUntestedSections() && m_changed );
}
private:
const TestCaseInfo* m_info;
RunStatus m_runStatus;
SectionInfo m_rootSection;
SectionInfo* m_currentSection;
SectionInfo* m_lastSectionToRun;
bool m_changed;
};
}
#endif // TWOBLUECUBES_INTERNAL_CATCH_RUNNING_TEST_HPP_INCLUDED

142
include/internal/catch_section_info.hpp Normal file
View File

@ -0,0 +1,142 @@
/*
* Created by Phil Nash on 4/5/2012
* Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
*
* 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_INTERNAL_CATCH_SECTION_INFO_HPP_INCLUDED
#define TWOBLUECUBES_INTERNAL_CATCH_SECTION_INFO_HPP_INCLUDED
#include "catch_common.h"
#include <map>
#include <string>
namespace Catch
{
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class SectionInfo
{
public:
enum Status
{
Root,
Unknown,
Branch,
TestedBranch,
TestedLeaf
};
///////////////////////////////////////////////////////////////////////
SectionInfo
(
SectionInfo* parent
)
: m_status( Unknown ),
m_parent( parent )
{
}
///////////////////////////////////////////////////////////////////////
SectionInfo
()
: m_status( Root ),
m_parent( NULL )
{
}
///////////////////////////////////////////////////////////////////////
~SectionInfo
()
{
deleteAllValues( m_subSections );
}
///////////////////////////////////////////////////////////////////////
bool shouldRun
()
const
{
return m_status < TestedBranch;
}
///////////////////////////////////////////////////////////////////////
bool ran
()
{
if( m_status < Branch )
{
m_status = TestedLeaf;
return true;
}
return false;
}
///////////////////////////////////////////////////////////////////////
void ranToCompletion
()
{
if( m_status == Branch && !hasUntestedSections() )
{
m_status = TestedBranch;
}
}
///////////////////////////////////////////////////////////////////////
SectionInfo* findSubSection
(
const std::string& name
)
{
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.find( name );
return it != m_subSections.end()
? it->second
: NULL;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* addSubSection
(
const std::string& name
)
{
SectionInfo* subSection = new SectionInfo( this );
m_subSections.insert( std::make_pair( name, subSection ) );
m_status = Branch;
return subSection;
}
///////////////////////////////////////////////////////////////////////
SectionInfo* getParent
()
{
return m_parent;
}
///////////////////////////////////////////////////////////////////////
bool hasUntestedSections
()
const
{
if( m_status == Unknown )
return true;
std::map<std::string, SectionInfo*>::const_iterator it = m_subSections.begin();
std::map<std::string, SectionInfo*>::const_iterator itEnd = m_subSections.end();
for(; it != itEnd; ++it )
{
if( it->second->hasUntestedSections() )
return true;
}
return false;
}
private:
Status m_status;
std::map<std::string, SectionInfo*> m_subSections;
SectionInfo* m_parent;
};
}
#endif // TWOBLUECUBES_INTERNAL_CATCH_SECTION_INFO_HPP_INCLUDED

1
include/internal/catch_test_case_registry_impl.hpp
View File

@ -18,7 +18,6 @@
#include <set>
#include <sstream>
#include <iostream> // !TBD DBG
namespace Catch
{
class TestRegistry : public ITestCaseRegistry

39
projects/SelfTest/MiscTests.cpp
View File

@ -96,26 +96,33 @@ TEST_CASE( "Sections/nested3", "nested SECTION tests" )
runner.runMatching( "./Sections/nested/a/b", "mock" );
CHECK( runner.getLog() ==
"[tc]( ./Sections/nested/a/b ){ "
"\\[tc] ./Sections/nested/a/b\n"
"[g]( test case run ){ "
"[s]( c ){ "
"[s]( d (leaf) ){ } [s]( d (leaf) ) "
"} [s]( c ) "
"} [g]( test case run )"
" \\[g] test case run\n"
" \\ [s] c\n"
" \\ [s] d (leaf)\n"
" / [s] d (leaf)\n"
" / [s] c\n"
" /[g] test case run\n"
"[g]( test case run ){ "
"[s]( c ){ "
"[s]( e (leaf) ){ } [s]( e (leaf) ) "
"} [s]( c ) "
"} [g]( test case run )"
" \\[g] test case run\n"
" \\ [s] c\n"
" \\ [s] e (leaf)\n"
" / [s] e (leaf)\n"
" / [s] c\n"
" /[g] test case run\n"
"[g]( test case run ){ "
"[s]( c ){ } [s]( c ) "
"[s]( f (leaf) ){ } [s]( f (leaf) ) "
"} [g]( test case run ) "
" \\[g] test case run\n"
" \\ [s] c\n"
" / [s] c\n"
" /[g] test case run\n"
"} [tc]( ./Sections/nested/a/b )" );
" \\[g] test case run\n"
" \\ [s] f (leaf)\n"
" / [s] f (leaf)\n"
" /[g] test case run\n"
"/[tc] ./Sections/nested/a/b\n" );
}

44
projects/SelfTest/catch_self_test.hpp
View File

@ -95,8 +95,7 @@ namespace Catch
const std::string& groupName
)
{
if( shouldRecord( recordGroups ) )
m_log << recordGroups << "( " << groupName << " ){ ";
openLabel( recordGroups, groupName );
}
virtual void EndGroup
@ -105,8 +104,7 @@ namespace Catch
const Totals& totals
)
{
if( shouldRecord( recordGroups ) )
m_log << " } " << recordGroups << "( " << groupName << " )";
closeLabel( recordGroups, groupName );
}
virtual void StartSection
@ -115,8 +113,7 @@ namespace Catch
const std::string description
)
{
if( shouldRecord( recordSections ) )
m_log << recordSections << "( " << sectionName << " ){ ";
openLabel( recordSections, sectionName );
}
virtual void EndSection
@ -125,8 +122,7 @@ namespace Catch
const Counts& assertions
)
{
if( shouldRecord( recordSections ) )
m_log << " } " << recordSections << "( " << sectionName << " )";
closeLabel( recordSections, sectionName );
}
virtual void StartTestCase
@ -134,8 +130,7 @@ namespace Catch
const TestCaseInfo& testInfo
)
{
if( shouldRecord( recordTestCases ) )
m_log << recordTestCases << "( " << testInfo.getName() << " ){ ";
openLabel( recordTestCases, testInfo.getName() );
}
virtual void EndTestCase
@ -146,8 +141,7 @@ namespace Catch
const std::string& stdErr
)
{
if( shouldRecord( recordTestCases ) )
m_log << " } " << recordTestCases << "( " << testInfo.getName() << " )";
closeLabel( recordTestCases, testInfo.getName() );
}
virtual void Result
@ -214,6 +208,32 @@ namespace Catch
{
return m_recorders.find( recorder ) != m_recorders.end();
}
void openLabel( const std::string& label, const std::string& arg = "" )
{
if( shouldRecord( label ) )
{
m_log << m_indent << "\\" << label;
if( !arg.empty() )
m_log << " " << arg;
m_log << "\n";
m_indent += " ";
}
}
void closeLabel( const std::string& label, const std::string& arg = "" )
{
if( shouldRecord( label ) )
{
m_indent = m_indent.substr( 0, m_indent.size()-1 );
m_log << m_indent << "/" << label;
if( !arg.empty() )
m_log << " " << arg;
m_log << "\n";
}
}
std::string m_indent;
std::ostringstream m_log;
std::set<std::string> m_recorders;
};

4
projects/XCode4/CatchSelfTest/CatchSelfTest.xcodeproj/project.pbxproj
View File

@ -88,6 +88,8 @@
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>"; };
4AB77CB51551AEA200857BF0 /* catch_ptr.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = catch_ptr.hpp; sourceTree = "<group>"; };
4AB77CB71553B72B00857BF0 /* catch_section_info.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = catch_section_info.hpp; sourceTree = "<group>"; };
4AB77CB81553BB3800857BF0 /* catch_running_test.hpp */ = {isa = PBXFileReference; path = catch_running_test.hpp; sourceTree = "<group>"; };
4AE1840A14EE4F230066340D /* catch_self_test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = catch_self_test.cpp; path = ../../../SelfTest/catch_self_test.cpp; sourceTree = "<group>"; };
/* End PBXFileReference section */
@ -197,6 +199,8 @@
4AB1C73714F97C1300F31DF7 /* catch_console_colour.hpp */,
4A3D7DD01503869D005F9203 /* catch_matchers.hpp */,
4AB77CB51551AEA200857BF0 /* catch_ptr.hpp */,
4AB77CB71553B72B00857BF0 /* catch_section_info.hpp */,
4AB77CB81553BB3800857BF0 /* catch_running_test.hpp */,
);
name = internal;
path = ../../../../include/internal;