testrunnerframe.cpp

c++单元测试框架

    if (idx != -1)
    {
        showFailureDetailAt( idx );
    }
}

// ----------------------------------------------------------------------------
// TestRunnerModelThreadInterface event handlers
// ----------------------------------------------------------------------------

void TestRunnerFrame::OnTestRunnerEvent(TestRunnerThreadEvent& event)
{
    event.process( this );
    event.Skip();
}

void TestRunnerFrame::eventTestRunStarted( CPPUNIT_NS::Test *test )
{
    if (test)
    {
        wxString status = _("Testing:");
        status += ' ';
        status += test->getName().c_str();
        SetStatusText( status );
    }
}

void TestRunnerFrame::eventTestRunFailed( TestFailureInfo *failure,
                                          int numberOfError,
                                          int numberOfFailure )
{
    // update counts
    m_labelNofErrors->SetLabel( wxString::Format("%d", numberOfError ) );
    m_labelNofFailures->SetLabel( wxString::Format("%d", numberOfFailure ) );

    // change colour of progress bar
    m_gaugeProgress->SetForegroundColour(*wxRED);

    // add failure to list
    int nofItems = m_listErrors->GetItemCount();
    long tmp = m_listErrors->InsertItem( nofItems, failure->isError() ? _("Error") : _("Failure") );
    if (tmp != -1)
    {
        m_listErrors->SetItemData( tmp, (long)failure );
        m_listErrors->SetItem( tmp, 1, failure->failedTestName().c_str() );
        m_listErrors->SetItem( tmp, 2, failure->thrownException()->message().shortDescription().c_str() );
        if ( failure->sourceLine().isValid() )
        {
            m_listErrors->SetItem( tmp, 3, wxString::Format( "%d", failure->sourceLine().lineNumber() ) );
            m_listErrors->SetItem( tmp, 4, failure->sourceLine().fileName().c_str() );
        }
    }

    // display the first error
    if (m_listErrors->GetItemCount() == 1)
    {
        showFailureDetailAt( 0 );
    }
}

void TestRunnerFrame::eventTestRunEnded( int numberOfRun )
{
    m_labelNofRuns->SetLabel( wxString::Format("%d", numberOfRun ) );

    m_gaugeProgress->SetValue( numberOfRun );
}

void TestRunnerFrame::eventTestRunnerThreadFinished()
{
    if (m_isRunning)
    {
        // scroll to the first error
        if (m_listErrors->GetItemCount() > 0)
        {
            m_listErrors->EnsureVisible( 0 );
        }

        // compute and display elapsed run time
        wxDateTime now = wxDateTime::UNow();
        wxTimeSpan elapsed = now.Subtract(m_startDateTime);

        wxString completionMessage = _("Finished:");

        wxLongLong ms = elapsed.GetMilliseconds();

        if (ms.GetHi() == 0)
        {
            double secondsElapsed = (double)ms.GetLo() / 1000;

            completionMessage += wxString::Format( " %3.3f ", secondsElapsed );
        }
        else
        {
            completionMessage += elapsed.Format( " %D d %H:%M:%S " );
        }

        completionMessage += _(" seconds");

        SetStatusText( completionMessage );
    }
    else
    {
        SetStatusText( _("Test stopped.") );
    }

    beCanRunTest();
}

// ----------------------------------------------------------------------------
// utility functions
// ----------------------------------------------------------------------------

void TestRunnerFrame::initView()
{
    CPPUNIT_NS::Test *rootTest = m_model->getRootTest();

    // default to running all tests
    addTestToHistory( rootTest );

    beCanRunTest();

    if ( m_model->isAutoRun() )
        runTest();
}

void TestRunnerFrame::resetView()
{
    m_gaugeProgress->SetValue(0);
    m_gaugeProgress->SetForegroundColour(*wxGREEN);

    m_labelNofTests->SetLabel( "0" );
    m_labelNofRuns->SetLabel( "0" );
    m_labelNofErrors->SetLabel( "0" );
    m_labelNofFailures->SetLabel( "0" );

    m_listErrors->DeleteAllItems();

    m_textDetails->Clear();

    SetStatusText( "" );

    beRunningTest();
}

// test selected; no test running
void TestRunnerFrame::beCanRunTest()
{
    m_isRunning = false;
    m_btnRun->Enable();
    m_btnBrowse->Enable();
    m_btnBrowse->SetFocus();
    m_btnStop->Disable();
    m_btnStop->SetLabel( _("Stop") );
    m_btnClose->Enable();
    m_choiceTest->Enable();
}

// test running
void TestRunnerFrame::beRunningTest()
{
    m_isRunning = true;
    m_btnRun->Disable();
    m_btnBrowse->Disable();
    m_btnStop->Enable();
    m_btnStop->SetFocus();
    m_btnStop->SetLabel( _("Stop") );
    m_btnClose->Disable();
    m_choiceTest->Disable();
}

// test being stopped
void TestRunnerFrame::beStoppingTest()
{
    m_btnStop->Disable();
    m_btnStop->SetLabel( _("Stopping") );
}

// called when tree item selected
void TestRunnerFrame::addTestToHistory( CPPUNIT_NS::Test *test )
{
    if ( test )
    {
        wxString testName( test->getName().c_str() );

        // delete test
        int idx = m_choiceTest->FindString( testName );
        if ( idx != -1 )
        {
            m_choiceTest->Delete( idx );
        }

        // [re-]add test
        m_choiceTest->Append( testName, test );

        // select test
        m_choiceTest->SetStringSelection( testName );

        // expand the size of the choice box when new tests are added;
        // i.e., choice needs to be fully visible
        if (idx == -1)
        {
            wxSize size = m_choiceTest->GetBestSize();
            m_choiceTest->SetSizeHints(size.GetWidth(), size.GetHeight());
            m_choiceTest->SetSize(size);
            m_choiceTest->Fit();

// FIXME: where does (magic number) 25 come from?
//        the wxRIGHT border was 30 when the control was added

            // update sizer so window resizing doesn't shrink the field
            wxRect rect = m_choiceTest->GetRect();
            m_choiceSizer->SetMinSize( rect.GetX() + rect.GetWidth() + 25, -1 );
        }
    }
}

void TestRunnerFrame::browseTests()
{
    TestBrowserDialog dlg( this );

    // test hierarchy (suites and test fixtures)
    dlg.setRootTest( m_model->getRootTest() );

    CPPUNIT_NS::Test *lastTest = getLastTestFromHistory();

    // select the last selected test (if any)
    dlg.goSelectTest( lastTest );

    if ( dlg.ShowModal() == wxID_OK )
    {
        CPPUNIT_NS::Test *test = dlg.getSelectedTest();

        if (test)
        {
            // adds the selected test to the test history
            addTestToHistory( test );

            // enable buttons, if history was empty, and now isn't
            if (getHistorySize() == 1)
                beCanRunTest();
        }
    }
}

void TestRunnerFrame::showFailureDetailAt( int idx )
{
    if (idx != -1)
    {
        TestFailureInfo *info = (TestFailureInfo *)m_listErrors->GetItemData( idx );

        if (!info)
        {
            m_textDetails->Clear();
        }
        else
        {
            m_textDetails->SetValue( info->thrownException()->what() );
        }
    }
}

void TestRunnerFrame::runTest()
{
    CPPUNIT_NS::Test *test;

    m_startDateTime = wxDateTime::UNow();

    resetView();

    test = getLastTestFromHistory();

    if (test)
    {
        int nofTestCases = test->countTestCases();

        m_labelNofTests->SetLabel( wxString::Format( "%d", nofTestCases ) );
        m_gaugeProgress->SetRange( nofTestCases );
    }

    beRunningTest();

    m_model->runTest(test);
}

void TestRunnerFrame::stopTest()
{
    beStoppingTest();

    m_isRunning = false;
    m_model->stopRunningTest();
}

int TestRunnerFrame::getHistorySize()
{
    return m_choiceTest->GetCount();
}

CPPUNIT_NS::Test *TestRunnerFrame::getLastTestFromHistory()
{
    int idx = m_choiceTest->GetSelection();

    return getTestFromIndex( idx );
}

CPPUNIT_NS::Test *TestRunnerFrame::getTestFromIndex( int idx )
{
    CPPUNIT_NS::Test *test = (CPPUNIT_NS::Test *)m_choiceTest->GetClientData( idx );

    return test;
}