testrunnermodel.cpp

c++单元测试框架

/////////////////////////////////////////////////////////////////////////////
// Name:        TestRunnerModel.cpp
// Purpose:     Implementation for class TestRunnerModel
// Author:      Baptiste Lepilleur
// Modified by: Anthon Pang
// Created:     2003.09.11
// RCS-ID:
// Copyright:   (C) 2003 by Anthon Pang and Baptiste Lepilleur
// Licence:     LGPL
// Reference:   cppunit/src/qttestrunner/TestRunnerModel.cpp
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx/wx.h".
#include <wx/wxprec.h>

#ifdef __BORLANDC__
#   pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
#   include <wx/wx.h>
#endif

#include "TestRunnerModel.h"

#ifndef CPPUNIT_TESTRESULT_H
#include <cppunit/TestResult.h>
#endif
#ifndef TESTFAILURE_INFO_H
#include "TestFailureInfo.h"
#endif
#ifndef TESTRUNNERTHREAD_H
#include "TestRunnerThread.h"
#endif
#ifndef TESTRUNNERSTARTEVENT_H
#include "TestRunnerStartEvent.h"
#endif
#ifndef TESTRUNNERFAILUREEVENT_H
#include "TestRunnerFailureEvent.h"
#endif
#ifndef TESTRUNNERENDEVENT_H
#include "TestRunnerEndEvent.h"
#endif
#ifndef TESTRUNNERTHREADFINISHEDEVENT_H
#include "TestRunnerThreadFinishedEvent.h"
#endif

// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(TestRunnerModel, wxEvtHandler)
    EVT_TEST_RUNNER_THREAD_EVENT(-1, TestRunnerModel::OnTestRunnerEvent)
END_EVENT_TABLE()

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------------

TestRunnerModel::TestRunnerModel( CPPUNIT_NS::Test *rootTest, bool autoRun )
  : m_rootTest( rootTest ), m_autoRun( autoRun ),
    m_result( 0 ), m_runnerThread( 0 ),
    m_nofTestCase( 0 ), m_nofTestCaseRun( 0 ),
    m_nofTestCaseError( 0 ), m_nofTestCaseFailure( 0 )
{
}

TestRunnerModel::~TestRunnerModel()
{
}

// ----------------------------------------------------------------------------
// CPPUNIT_NS::TestListener interface
// ----------------------------------------------------------------------------

// Called from the TestRunnerThread.
void TestRunnerModel::startTest( CPPUNIT_NS::Test *test )
{
    TestRunnerStartEvent evt(test);
    wxPostEvent(this, evt);
}

// Called from the TestRunnerThread.
void TestRunnerModel::addFailure( const CPPUNIT_NS::TestFailure &failure )
{
    TestFailureInfo *failureInfo;
    bool isError = failure.isError();

    {
        wxMutexLocker guard( m_lock );

        if ( isError )
            ++m_nofTestCaseError;
        else
            ++m_nofTestCaseFailure;

        failureInfo = new TestFailureInfo( failure.failedTest(),
                                           failure.thrownException(),
                                           isError );
        m_failures.Add( failureInfo );
    }
    TestRunnerFailureEvent evt(failureInfo, m_nofTestCaseError, m_nofTestCaseFailure);
    wxPostEvent(this, evt);
}

// Called from the TestRunnerThread.
void TestRunnerModel::endTest( CPPUNIT_NS::Test *test )
{
    int numberOfTestCaseRun;

    {
        wxMutexLocker guard( m_lock );
        numberOfTestCaseRun = ++m_nofTestCaseRun;
    }
    TestRunnerEndEvent evt( numberOfTestCaseRun );
    wxPostEvent(this, evt);
}

// ----------------------------------------------------------------------------
// TestRunnerModelThreadInterface event handler and interface
// ----------------------------------------------------------------------------

// Called from TestRunnerStartEvent,
//             TestRunnerFailureEvent,
//             TestRunnerEndEvent,
//          or TestRunnerThreadFinishedEvent
void TestRunnerModel::OnTestRunnerEvent(TestRunnerThreadEvent& event)
{
    event.process( this );
    event.Skip();
}

void TestRunnerModel::eventTestRunStarted( CPPUNIT_NS::Test *test )
{
}

void TestRunnerModel::eventTestRunFailed( TestFailureInfo *failure,
                                          int numberOfError,
                                          int numberOfFailure )
{
}

void TestRunnerModel::eventTestRunEnded( int numberOfRun )
{
}

void TestRunnerModel::eventTestRunnerThreadFinished()
{
    m_runnerThread = 0;
}

// ----------------------------------------------------------------------------
// Manipulators
// ----------------------------------------------------------------------------

void TestRunnerModel::setRootTest( CPPUNIT_NS::Test *test )
{
    m_rootTest = test;
}

void TestRunnerModel::resetTestReportFor( CPPUNIT_NS::Test *testToRun )
{
    if ( isTestRunning() )
        return;

    {
        wxMutexLocker guard( m_lock );

        m_nofTestCase = testToRun->countTestCases();
        m_nofTestCaseRun = 0;
        m_nofTestCaseError = 0;
        m_nofTestCaseFailure = 0;

        m_failures.Clear();
    }
}

void TestRunnerModel::runTest( CPPUNIT_NS::Test *testToRun )
{
    if ( isTestRunning() )
        return;

    resetTestReportFor( testToRun );

    {
        wxMutexLocker guard( m_lock );

        if ( m_result )  delete m_result;
        m_result = new CPPUNIT_NS::TestResult();
        m_result->addListener( this );
    }

    wxMutexLocker guard( m_lock );
    m_runnerThread = new TestRunnerThread( testToRun,
                                           m_result,
                                           this,
                                           new TestRunnerThreadFinishedEvent() );
    if (!m_runnerThread)
    {
        wxLogMessage("Unable to allocate test runner thread!");

        TestRunnerThreadFinishedEvent evt;
        wxPostEvent(this, evt);
        return;
    }

    if (m_runnerThread->Create() != wxTHREAD_NO_ERROR)
    {
        m_runnerThread->Delete();
        m_runnerThread = 0;

        wxLogMessage("Unable to create test runner thread!");

        TestRunnerThreadFinishedEvent evt;
        wxPostEvent(this, evt);
        return;
    }

    m_runnerThread->Run();
}

void TestRunnerModel::stopRunningTest()
{
    {
        wxMutexLocker guard( m_lock );
        if ( m_result == 0 )
            return;
    }

    if ( isTestRunning() )
    {
        wxMutexLocker guard( m_lock );
        m_result->stop();

        m_runnerThread->Wait();
        m_runnerThread->Delete();
        m_runnerThread = 0;
    }
}

// ----------------------------------------------------------------------------
// Accessors
// ----------------------------------------------------------------------------

bool TestRunnerModel::isAutoRun()
{
    wxMutexLocker guard( m_lock );
    return m_autoRun;
}

bool TestRunnerModel::isTestRunning()
{
    wxMutexLocker guard( m_lock );

    return ( m_runnerThread && m_runnerThread->IsRunning() );
}

CPPUNIT_NS::Test *TestRunnerModel::getRootTest(void) const
{
    return m_rootTest;
}

int TestRunnerModel::getNumberOfTestCase()
{
    wxMutexLocker guard( m_lock );
    return m_nofTestCase;
}

int TestRunnerModel::getNumberOfTestCaseRun()
{
    wxMutexLocker guard( m_lock );
    return m_nofTestCaseRun;
}

int TestRunnerModel::getNumberOfTestCaseError()
{
    wxMutexLocker guard( m_lock );
    return m_nofTestCaseError;
}

int TestRunnerModel::getNumberOfTestCaseFailure()
{
    wxMutexLocker guard( m_lock );
    return m_nofTestCaseFailure;
}