// //////////////////////////////////////////////////////////////////////////

// Implementation file ClockerModel.cpp for class ClockerModel

// (c)Copyright 2000, Baptiste Lepilleur.

// Created: 2002/06/14

// //////////////////////////////////////////////////////////////////////////

#include "ClockerModel.h"

#include <cppunit/config/SourcePrefix.h>

ClockerModel::ClockerModel()

    : m_testCaseCount( 0 )

    , m_totalTestCaseTime( 0 )

{

}

ClockerModel::~ClockerModel()

{

}

void 

ClockerModel::setExpectedTestCount( int count )

{

  m_tests.reserve( count );

}

void 

ClockerModel::enterTest( CPPUNIT_NS::Test *test,

                         bool isSuite )

{

  m_currentPath.add( test );

  int testIndex = m_tests.size();

  if ( !m_testIndexes.empty() )

    m_tests[ m_testIndexes.top() ].m_childIndexes.push_back( testIndex );

  m_testIndexes.push( testIndex );

  m_testToIndexes.insert( TestToIndexes::value_type( test, testIndex ) );

  TestInfo info;

  info.m_timer.start();

  info.m_path = m_currentPath;

  info.m_isSuite = isSuite;

  m_tests.push_back( info );

  if ( !isSuite )

    ++m_testCaseCount;

}

void 

ClockerModel::exitTest( CPPUNIT_NS::Test *test,

                        bool isSuite )

{

  m_tests[ m_testIndexes.top() ].m_timer.finish();

  if ( !isSuite )

    m_totalTestCaseTime += m_tests.back().m_timer.elapsedTime();

  m_currentPath.up();

  m_testIndexes.pop();

}

double 

ClockerModel::totalElapsedTime() const

{

  return m_tests[0].m_timer.elapsedTime();

}

double 

ClockerModel::averageTestCaseTime() const

{

  double average = 0;

  if ( m_testCaseCount > 0 )

    average = m_totalTestCaseTime / m_testCaseCount;

  return average;

}

double 

ClockerModel::testTimeFor( int testIndex ) const

{

  return m_tests[ testIndex ].m_timer.elapsedTime();

}

std::string 

ClockerModel::timeStringFor( double time )

{

  char buffer[320];

  const char *format;

  if ( time < 1 )

    format = "%2.3f";

  else if ( time < 10 )

    format = "%3.2f";

  else if (time < 100 )

    format = "%4.1f";

  else

    format = "%6f";

  ::sprintf( buffer, format, time );

  return buffer;

}

bool 

ClockerModel::isSuite( int testIndex ) const

{

  return m_tests[ testIndex ].m_isSuite;

}

const CPPUNIT_NS::TestPath &

ClockerModel::testPathFor( int testIndex ) const

{

  return m_tests[ testIndex ].m_path;

}

int 

ClockerModel::indexOf( CPPUNIT_NS::Test *test ) const

{

  TestToIndexes::const_iterator itFound = m_testToIndexes.find( test );

  if ( itFound != m_testToIndexes.end() )

    return itFound->second;

  return -1;

}

int 

ClockerModel::childCountFor( int testIndex ) const

{

  return m_tests[ testIndex ].m_childIndexes.size();

}

int 

ClockerModel::childAtFor( int testIndex, 

                          int chidIndex ) const

{

  return m_tests[ testIndex ].m_childIndexes[ chidIndex ];

}