testexecfw/symbianunittestfw/sutfw/sutfwcore/sutfwframework/src/symbianunittestresult.cpp
/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include "symbianunittestresult.h"
#include "symbianunittestfailure.h"
#include "sutlogger.h"
_LIT8( KSymbianUnitTestLeaveCodeMessageFormat, "Leave code: %d" );
_LIT8( KSymbianUnitTestMemoryLeakPhrase, "Leaked %d bytes of memory" );
_LIT8( KSymbianUnitTestPanicPhrase, "Panic: " );
_LIT8( KSymbianUnitTestPanicReasonFormat, ", reason: %d" );
_LIT8( KSymbianUnitTestAllocFailureRateFormat, ", alloc failure rate: %d" );
_LIT8( KSymbianUnitTestSetupFailed, "Leave from the setup function: %d" );
_LIT8( KSymbianUnitTestErrorFormat, "Test Failed File[%S], Line[%d], Msg[%S]");
_LIT8( KSymbianUnitTestFailed, "Test Failed Reason[%S]");
_LIT( KSymbianUnitTestPass, "pass" );
_LIT( KSymbianUnitTestFail, "fail" );
_LIT8( KSymbianUnitTestTimedOut, "Timed out: %d s" );
const TInt KMax64BitUintLengthAsDescriptor = 20;
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CSymbianUnitTestResult* CSymbianUnitTestResult::NewLC()
{
CSymbianUnitTestResult* self = new( ELeave )CSymbianUnitTestResult;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CSymbianUnitTestResult* CSymbianUnitTestResult::NewL()
{
CSymbianUnitTestResult* self = CSymbianUnitTestResult::NewLC();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CSymbianUnitTestResult::CSymbianUnitTestResult()
: iOriginalHeap( User::Heap() )
{
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::ConstructL()
{
iCurrentTestName = KNullDesC().AllocL();
iTestCaseNames = new (ELeave)CDesCArrayFlat(10);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CSymbianUnitTestResult::~CSymbianUnitTestResult()
{
delete iCurrentTestName;
delete iTestCaseNames;
iFailures.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CSymbianUnitTestResult::TestCount() const
{
return iTestCount;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CSymbianUnitTestResult::PassedTestCount() const
{
return ( iTestCount - iFailures.Count() );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
RPointerArray< CSymbianUnitTestFailure >& CSymbianUnitTestResult::Failures()
{
return iFailures;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::StartTestL( const TDesC& aTestName )
{
SUT_LOG_FORMAT(_L("StartCase[%S]"), &aTestName);
HBufC* tmp = aTestName.AllocL();
delete iCurrentTestName;
iCurrentTestName = tmp;
iTestCount++;
iCurrentResult = ETrue;
iTime.UniversalTime();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::EndTestL()
{
TTime now;
now.UniversalTime();
TTimeIntervalMicroSeconds microSeconds = now.MicroSecondsFrom(iTime);
TReal64 ms= microSeconds.Int64();
//log the test time in milliseconds
SUT_LOG_FORMAT2(_L("EndCase Result[%S] Time[%d]ms"),
iCurrentResult?&KSymbianUnitTestPass:&KSymbianUnitTestFail,
microSeconds.Int64()/1000);
if (iCurrentResult)
{
//only add passed case to the testcasenames
iTestCaseNames->AppendL(*iCurrentTestName);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddSetupErrorL( TInt aError )
{
const TInt KLength =
KSymbianUnitTestSetupFailed().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* errorAsText = HBufC8::NewLC( KLength );
errorAsText->Des().Format( KSymbianUnitTestSetupFailed, aError );
User::LeaveIfError( AddFailure( *errorAsText, 0 ) );
CleanupStack::PopAndDestroy( errorAsText );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddLeaveFromTestL(
TInt aLeaveCode,
TInt aAllocFailureRate )
{
const TInt KLength =
KSymbianUnitTestLeaveCodeMessageFormat().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* failureMsg = HBufC8::NewLC( KLength );
failureMsg->Des().Format(
KSymbianUnitTestLeaveCodeMessageFormat, aLeaveCode );
User::LeaveIfError( AddFailure( *failureMsg, aAllocFailureRate ) );
CleanupStack::PopAndDestroy( failureMsg );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddMemoryLeakInfoL(
TInt aLeakedMemory,
TInt aAllocFailureRate )
{
const TInt KLength =
KSymbianUnitTestMemoryLeakPhrase().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* failureMsg = HBufC8::NewLC( KLength );
failureMsg->Des().Format(
KSymbianUnitTestMemoryLeakPhrase, aLeakedMemory );
User::LeaveIfError( AddFailure( *failureMsg, aAllocFailureRate ) );
CleanupStack::PopAndDestroy( failureMsg );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddPanicInfoL(
const TExitCategoryName& aPanicCategory,
TInt aPanicReason,
TInt aAllocFailureRate )
{
const TInt KLength =
KSymbianUnitTestPanicPhrase().Length() + aPanicCategory.Length() +
KSymbianUnitTestPanicReasonFormat().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* panicAsText = HBufC8::NewLC( KLength );
TPtr8 panicAsTextPtr( panicAsText->Des() );
panicAsTextPtr.Append( KSymbianUnitTestPanicPhrase );
panicAsTextPtr.Append( aPanicCategory );
panicAsTextPtr.AppendFormat(
KSymbianUnitTestPanicReasonFormat, aPanicReason );
User::LeaveIfError( AddFailure( panicAsTextPtr, aAllocFailureRate ) );
CleanupStack::PopAndDestroy( panicAsText );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CSymbianUnitTestResult::AddAssertFailure(
const TDesC8& aFailureMessage,
TInt aLineNumber,
const TDesC8& aFileName )
{
RHeap* currentHeap = User::SwitchHeap( &iOriginalHeap );
TRAPD( err, AddAssertFailureL( aFailureMessage, aLineNumber, aFileName ) );
User::SwitchHeap( currentHeap );
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddAssertFailureL(
const TDesC8& aFailureMessage,
TInt aLineNumber,
const TDesC8& aFileName )
{
CSymbianUnitTestFailure* failure =
CSymbianUnitTestFailure::NewLC(
*iCurrentTestName, aFailureMessage, aLineNumber, aFileName );
SUT_LOG_FORMAT3(KSymbianUnitTestErrorFormat, &aFileName, aLineNumber, &aFailureMessage);
iCurrentResult = EFalse;
iFailures.AppendL( failure );
CleanupStack::Pop( failure );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddTimeOutErrorL( TInt aTimeOut )
{
const TInt KLength =
KSymbianUnitTestTimedOut().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* errorAsText = HBufC8::NewLC( KLength );
errorAsText->Des().Format( KSymbianUnitTestTimedOut, aTimeOut );
User::LeaveIfError( AddFailure( *errorAsText, 0 ) );
CleanupStack::PopAndDestroy( errorAsText );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CSymbianUnitTestResult::AddFailure(
const TDesC8& aFailureText,
TInt aAllocFailureRate )
{
RHeap* currentHeap = User::SwitchHeap( &iOriginalHeap );
TRAPD( err, AddFailureL( aFailureText, aAllocFailureRate ) )
User::SwitchHeap( currentHeap );
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestResult::AddFailureL(
const TDesC8& aFailureText,
TInt aAllocFailureRate )
{
CSymbianUnitTestFailure* failure = NULL;
if ( aAllocFailureRate > 0 )
{
const TInt KLength =
aFailureText.Length() +
KSymbianUnitTestAllocFailureRateFormat().Length() +
KMax64BitUintLengthAsDescriptor;
HBufC8* failureMsg = HBufC8::NewLC( KLength );
failureMsg->Des() = aFailureText;
failureMsg->Des().AppendFormat(
KSymbianUnitTestAllocFailureRateFormat, aAllocFailureRate );
failure = CSymbianUnitTestFailure::NewL(
*iCurrentTestName, *failureMsg, KErrNotFound, KNullDesC8 );
CleanupStack::PopAndDestroy( failureMsg );
CleanupStack::PushL( failure );
}
else
{
failure = CSymbianUnitTestFailure::NewLC(
*iCurrentTestName, aFailureText, KErrNotFound, KNullDesC8 );
}
SUT_LOG_FORMAT(KSymbianUnitTestFailed, &aFailureText);
iCurrentResult = EFalse;
iFailures.AppendL( failure );
CleanupStack::Pop( failure );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
const CDesCArray& CSymbianUnitTestResult::TestCaseNames() const
{
return *iTestCaseNames;
}