Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
path: root/projects/SelfTest/PartTrackerTests.cpp
diff options
context:
space:
mode:
authorPhil Nash2015-10-23 18:20:33 +0100
committerPhil Nash2015-10-23 18:20:33 +0100
commit1cb993970ad64a8dde8428fabc791e273d34520c (patch)
tree97b4ca59ff20ed313ea587597525ce5b3421148d /projects/SelfTest/PartTrackerTests.cpp
parentd43a47efca81129eb079b924e61d8cbcd12d8f3c (diff)
downloadcatch3-1cb993970ad64a8dde8428fabc791e273d34520c.tar.gz
First cut of new section/ part tracking
Diffstat (limited to 'projects/SelfTest/PartTrackerTests.cpp')
-rw-r--r--projects/SelfTest/PartTrackerTests.cpp422
1 files changed, 422 insertions, 0 deletions
diff --git a/projects/SelfTest/PartTrackerTests.cpp b/projects/SelfTest/PartTrackerTests.cpp
new file mode 100644
index 00000000..6323f376
--- /dev/null
+++ b/projects/SelfTest/PartTrackerTests.cpp
@@ -0,0 +1,422 @@
+/*
+ * Created by Phil on 1/10/2015.
+ * Copyright 2015 Two Blue Cubes Ltd
+ *
+ * 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)
+ */
+#include "internal/catch_suppress_warnings.h"
+#include "internal/catch_compiler_capabilities.h"
+#include "internal/catch_ptr.hpp"
+
+#ifdef __clang__
+//# pragma clang diagnostic ignored "-Wpadded"
+//# pragma clang diagnostic ignored "-Wc++98-compat"
+#endif
+
+#include <cassert>
+#include <memory>
+#include <vector>
+
+namespace Catch
+{
+ struct IContainerPart;
+
+ struct ITrackedPart : SharedImpl<> {
+ virtual ~ITrackedPart() {}
+ virtual std::string name() const = 0;
+ virtual bool isUnstarted() const = 0;
+ virtual bool isCompleteOrFailed() const = 0;
+ virtual bool isComplete() const = 0;
+ virtual bool isOpen() const = 0;
+
+ virtual IContainerPart& parent() = 0;
+
+ virtual void close() = 0;
+ virtual void fail() = 0;
+ };
+
+ struct IContainerPart : ITrackedPart {
+ virtual void addChild( Ptr<ITrackedPart> const& child ) = 0;
+ virtual ITrackedPart* findChild( std::string const& name ) = 0;
+ virtual void openChild() = 0;
+ virtual void childFailed() = 0;
+ };
+
+
+ class TrackerContext {
+
+ enum RunState {
+ NotStarted,
+ Executing,
+ CompletedCycle
+ };
+
+ Ptr<IContainerPart> m_rootPartTracker;
+ IContainerPart* m_currentPart;
+ RunState m_runState;
+
+ public:
+
+ static TrackerContext& instance() {
+ static TrackerContext s_instance;
+ return s_instance;
+ }
+
+ TrackerContext()
+ : m_currentPart( CATCH_NULL ),
+ m_runState( NotStarted )
+ {}
+
+ int i() {
+ return 42;
+ }
+
+ IContainerPart& startRun();
+
+ void endRun() {
+ m_rootPartTracker.reset();
+ m_currentPart = CATCH_NULL;
+ m_runState = NotStarted;
+ }
+
+ void startCycle() {
+ m_currentPart = m_rootPartTracker.get();
+ m_runState = Executing;
+ }
+ void completeCycle() {
+ m_runState = CompletedCycle;
+ }
+
+ bool completedCycle() const {
+ return m_runState == CompletedCycle;
+ }
+
+ IContainerPart& currentPart() {
+ return *m_currentPart;
+ }
+ void setCurrentPart( IContainerPart* part ) {
+ m_currentPart = part;
+ }
+
+ ITrackedPart* findPart( std::string const& name ) {
+ return m_currentPart->findChild( name );
+ }
+
+
+ private:
+ };
+
+
+ class PartTracker : public IContainerPart {
+ enum RunState {
+ NotStarted,
+ Executing,
+ ExecutingChildren,
+ CompletedSuccessfully,
+ Failed,
+ ChildFailed
+ };
+ class TrackerHasName {
+ std::string m_name;
+ public:
+ TrackerHasName( std::string const& name ) : m_name( name ) {}
+ bool operator ()( Ptr<ITrackedPart> const& tracker ) {
+ return tracker->name() == m_name;
+ }
+ };
+ typedef std::vector<Ptr<ITrackedPart> > Children;
+ std::string m_name;
+ TrackerContext& m_ctx;
+ IContainerPart* m_parent;
+ Children m_children;
+ RunState m_runState;
+ public:
+ PartTracker( std::string const& name, TrackerContext& ctx, IContainerPart* parent )
+ : m_name( name ),
+ m_ctx( ctx ),
+ m_parent( parent ),
+ m_runState( NotStarted ) {}
+
+ virtual std::string name() const CATCH_OVERRIDE {
+ return m_name;
+ }
+
+ virtual bool isCompleteOrFailed() const CATCH_OVERRIDE {
+ return m_runState == CompletedSuccessfully || m_runState == Failed;
+ }
+ virtual bool isComplete() const CATCH_OVERRIDE {
+ return m_runState == CompletedSuccessfully;
+ }
+ virtual bool isUnstarted() const CATCH_OVERRIDE {
+ return m_runState == NotStarted;
+ }
+ virtual bool isOpen() const CATCH_OVERRIDE {
+ return m_runState == Executing || m_runState == ExecutingChildren;
+ }
+
+
+ virtual void addChild( Ptr<ITrackedPart> const& child ) CATCH_OVERRIDE {
+ m_children.push_back( child );
+ size_t childCount = m_children.size();
+ }
+
+ virtual ITrackedPart* findChild( std::string const& name ) CATCH_OVERRIDE {
+ Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) );
+ return( it != m_children.end() )
+ ? it->get()
+ : CATCH_NULL;
+ }
+ virtual IContainerPart& parent() CATCH_OVERRIDE {
+ assert( m_parent ); // Should always be non-null except for root
+ return *m_parent;
+ }
+
+ virtual void openChild() CATCH_OVERRIDE {
+ if( m_runState != ExecutingChildren ) {
+ m_runState = ExecutingChildren;
+ if( m_parent )
+ m_parent->openChild();
+ }
+ }
+ virtual void childFailed() CATCH_OVERRIDE {
+ assert( m_runState == ExecutingChildren );
+ m_runState = ChildFailed;
+ if( m_parent )
+ m_parent->childFailed();
+ }
+ void open() {
+ m_runState = Executing;
+ moveToThis();
+ if( m_parent )
+ m_parent->openChild();
+ }
+
+ virtual void close() CATCH_OVERRIDE {
+ switch( m_runState ) {
+ case Executing:
+ m_runState = CompletedSuccessfully;
+ break;
+ case ExecutingChildren:
+ if( !hasUnstartedChildren() )
+ m_runState = CompletedSuccessfully;
+ break;
+ case ChildFailed:
+ m_runState = ExecutingChildren;
+ break;
+ default:
+ throw std::logic_error( "Unexpected state" );
+ }
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+ virtual void fail() CATCH_OVERRIDE {
+ m_runState = Failed;
+ if( m_parent )
+ m_parent->childFailed();
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+ private:
+ void moveToParent() {
+ m_ctx.setCurrentPart( m_parent );
+ }
+ void moveToThis() {
+ m_ctx.setCurrentPart( this );
+ }
+
+ bool hasUnstartedChildren() const {
+ return !m_children.empty() && m_children.back()->isUnstarted();
+ }
+ };
+
+ IContainerPart& TrackerContext::startRun() {
+ m_rootPartTracker = new PartTracker( "{root}", *this, CATCH_NULL );
+ m_currentPart = CATCH_NULL;
+ m_runState = Executing;
+ return *m_rootPartTracker;
+ }
+
+ class LocalContext {
+
+ public:
+ TrackerContext& operator()() const {
+ return TrackerContext::instance();
+ }
+ };
+
+ class SectionPart : public PartTracker {
+ public:
+ SectionPart( std::string const& name, TrackerContext& ctx, IContainerPart* parent )
+ : PartTracker( name, ctx, parent )
+ {}
+
+ static SectionPart& acquire( TrackerContext& ctx, std::string const& name ) {
+ SectionPart* section = CATCH_NULL;
+
+ IContainerPart& currentPart = ctx.currentPart();
+ if( ITrackedPart* part = currentPart.findChild( name ) ) {
+ section = dynamic_cast<SectionPart*>( part );
+ assert( section );
+ }
+ else {
+ section = new SectionPart( name, ctx, &currentPart );
+ currentPart.addChild( section );
+ }
+ if( !ctx.completedCycle() && !section->isCompleteOrFailed() ) {
+ section->open();
+ }
+ return *section;
+ }
+ };
+
+} // namespace Catch
+
+inline Catch::TrackerContext& C_A_T_C_H_Context() {
+ return Catch::TrackerContext::instance();
+}
+
+// -------------------
+
+#include "catch.hpp"
+
+using namespace Catch;
+
+inline void testCase( Catch::LocalContext const& C_A_T_C_H_Context ) {
+
+ REQUIRE( C_A_T_C_H_Context().i() == 42 );
+}
+
+TEST_CASE( "PartTracker" ) {
+
+ TrackerContext ctx;
+ ctx.startRun();
+ ctx.startCycle();
+
+ SectionPart& testCase = SectionPart::acquire( ctx, "Testcase" );
+ REQUIRE( testCase.isComplete() == false );
+
+ SectionPart& s1 = SectionPart::acquire( ctx, "S1" );
+ REQUIRE( s1.isComplete() == false );
+
+ SECTION( "successfully close one section" ) {
+ s1.close();
+ REQUIRE( s1.isComplete() == true );
+ REQUIRE( testCase.isCompleteOrFailed() == false );
+
+ testCase.close();
+ REQUIRE( testCase.isComplete() == true );
+
+ REQUIRE( ctx.completedCycle() == true );
+ }
+
+ SECTION( "fail one section" ) {
+ s1.fail();
+ REQUIRE( s1.isComplete() == false );
+ REQUIRE( s1.isCompleteOrFailed() == true );
+ REQUIRE( testCase.isComplete() == false );
+ REQUIRE( testCase.isCompleteOrFailed() == false );
+
+ testCase.close();
+ REQUIRE( ctx.completedCycle() == true );
+ REQUIRE( testCase.isComplete() == false );
+
+ SECTION( "re-enter after failed section" ) {
+ ctx.startCycle();
+ SectionPart& testCase2 = SectionPart::acquire( ctx, "Testcase" );
+ REQUIRE( testCase2.isComplete() == false );
+
+ SectionPart& s1b = SectionPart::acquire( ctx, "S1" );
+ REQUIRE( s1b.isComplete() == false );
+
+ testCase2.close();
+ REQUIRE( ctx.completedCycle() == true );
+ REQUIRE( testCase.isComplete() == true );
+ REQUIRE( testCase.isCompleteOrFailed() == true );
+ }
+ SECTION( "re-enter after failed section and find next section" ) {
+ ctx.startCycle();
+ SectionPart& testCase2 = SectionPart::acquire( ctx, "Testcase" );
+ REQUIRE( testCase2.isComplete() == false );
+
+ SectionPart& s1b = SectionPart::acquire( ctx, "S1" );
+ REQUIRE( s1b.isComplete() == false );
+
+ SectionPart& s2 = SectionPart::acquire( ctx, "S2" );
+ REQUIRE( s2.isOpen() );
+ s2.close();
+ REQUIRE( ctx.completedCycle() == true );
+
+ testCase2.close();
+ REQUIRE( testCase.isComplete() == true );
+ REQUIRE( testCase.isCompleteOrFailed() == true );
+ }
+ }
+
+ SECTION( "successfully close one section, then find another" ) {
+ s1.close();
+ REQUIRE( ctx.completedCycle() == true );
+
+ SectionPart& s2 = SectionPart::acquire( ctx, "S2" );
+ REQUIRE( s2.isComplete() == false );
+ REQUIRE( s2.isOpen() == false );
+
+ testCase.close();
+ REQUIRE( testCase.isComplete() == false );
+
+ SECTION( "Re-enter - skip S1 and enter S2" ) {
+ ctx.startCycle();
+ SectionPart& testCase2 = SectionPart::acquire( ctx, "Testcase" );
+ REQUIRE( testCase2.isComplete() == false );
+
+ SectionPart& s1b = SectionPart::acquire( ctx, "S1" );
+ REQUIRE( s1b.isComplete() == true );
+
+ SectionPart& s2b = SectionPart::acquire( ctx, "S2" );
+ REQUIRE( s2b.isComplete() == false );
+ REQUIRE( s2b.isOpen() );
+
+ REQUIRE( ctx.completedCycle() == false );
+
+ SECTION ("Successfully close S2") {
+ s2b.close();
+ REQUIRE( ctx.completedCycle() == true );
+
+ REQUIRE( s2b.isComplete() == true );
+ REQUIRE( testCase2.isCompleteOrFailed() == false );
+
+ testCase2.close();
+ REQUIRE( testCase2.isComplete() == true );
+ }
+ SECTION ("fail S2") {
+ s2b.fail();
+ REQUIRE( ctx.completedCycle() == true );
+
+ REQUIRE( s2b.isComplete() == false );
+ REQUIRE( s2b.isCompleteOrFailed() == true );
+ REQUIRE( testCase2.isCompleteOrFailed() == false );
+
+ testCase2.close();
+ REQUIRE( testCase2.isComplete() == false );
+ }
+ }
+ }
+
+ SECTION( "open a nested section" ) {
+ SectionPart& s2 = SectionPart::acquire( ctx, "S2" );
+ REQUIRE( s2.isOpen() == true );
+
+ s2.close();
+ REQUIRE( s2.isComplete() == true );
+ REQUIRE( s1.isComplete() == false );
+
+ s1.close();
+ REQUIRE( s1.isComplete() == true );
+ REQUIRE( testCase.isComplete() == false );
+
+ testCase.close();
+ REQUIRE( testCase.isComplete() == true );
+
+ }
+
+}