// Copyright (c) 2006-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 <f32file.h>
#include "tsu_mmf_mmruf_step.h"
static const TInt KTestStepNameSize = 22; // MM-MMF-MMRUF-U-xxxx-HP
/*
**
*/
RMMRUFTestStep::RMMRUFTestStep(const TTestSpec* aTestSpec)
: iTestSpec(aTestSpec)
{
ASSERT(iTestSpec != NULL);
_LIT(KTestStep, "MM-MMF-MMRUF-U-%04d-HP");
TBuf<KTestStepNameSize> temp;
temp.Zero();
temp.AppendFormat(KTestStep, iTestSpec->iTestNumber);
iTestStepName = temp;
}
/*
**
*/
RMMRUFTestStep::~RMMRUFTestStep()
{
Close();
}
/*
**
*/
RMMRUFTestStep* RMMRUFTestStep::NewL(const TTestSpec* aTestSpec)
{
return new(ELeave) RMMRUFTestStep(aTestSpec);
}
/*
**
*/
TVerdict RMMRUFTestStep::DoTestStepPreambleL()
{
User::LeaveIfError(iAppArc.Connect());
return EPass;
}
/*
**
*/
TVerdict RMMRUFTestStep::DoTestStepPostambleL()
{
iAppArc.Close();
return EPass;
}
/*
**
*/
TVerdict RMMRUFTestStep::DoTestStepL()
{
iTestStepResult = EFail;
TPtrC filename(iTestSpec->iFileName);
INFO_PRINTF2(_L("Testing file: %S"), &filename);
RFile file;
TInt err = file.Open(iAppArc.FileServer(), filename, EFileRead | EFileShareAny);
if (err != KErrNone)
{
INFO_PRINTF3(_L("RFile.Open(\"%S\") failed: %d"), &filename, err);
User::Leave(err);
}
CleanupClosePushL(file);
TDataRecognitionResult dataType;
err = iAppArc.Recognise(file, dataType);
if (err != KErrNone)
{
iTestStepResult = EInconclusive;
INFO_PRINTF2(_L("RApaLsSession.RecognizeData() failed: %d"), err);
User::Leave(err);
}
CleanupStack::Pop(); // file
// Check the results.
TPtrC8 resMime(dataType.iDataType.Des8());
TPtrC8 expectedMime(iTestSpec->iExpectedMimeType);
if (expectedMime.Compare(resMime) == 0)
{
if (iTestSpec->iTestNumber >= 600)
{
// Negative testing above 600
// These are negative tests. So Mime type must be empty
if (resMime.Compare(_L8("")) == 0)
{
iTestStepResult = EPass;
return iTestStepResult;
}
}
// DEF129505 - MMRuf incorrectly recognises unicode text files as MP3 files
else if (iTestSpec->iTestNumber == 500)
{
iTestStepResult = EPass;
return iTestStepResult;
}
// Set the result to EFail initially and change it to EPass
// further down in the code after checking the expected confidence.
iTestStepResult = EFail;
TBuf<64> confidence;
switch (dataType.iConfidence)
{
case KConfCertain:
confidence.Copy(_L("KConfCertain"));
break;
case KConfProbable:
confidence.Copy(_L("KConfProbable"));
break;
case KConfPossible:
confidence.Copy(_L("KConfPossible"));
break;
case KConfNotRecognised:
confidence.Copy(_L("KConfNotRecognised"));
break;
default:
// Safe Guard: This will never happen
break;
}
// #############################################################
// SPECIAL CASES: There are some formats that are never recognised
// with confidence = ECertain. Deal with these here.
switch (iTestSpec->iTestNumber)
{
case 55: // RAM.
case 115: // SDP
case 116: // SDP
case 117: // SDP
case 118: // SDP
case 119: // SDP
case 120: // SDP
case 121: // SDP
case 122: // SDP
if (dataType.iConfidence != KConfProbable)
{
INFO_PRINTF2(_L("Bad confidence level: %S, expected KConfProbable"), &confidence);
}
else
{
iTestStepResult = EPass;
}
return iTestStepResult;
default:
// Deliberate fall-through.
break;
}
// Mod of 3 cos there are 3 test cases for each format
TInt res = iTestSpec->iTestNumber % 3;
switch (res)
{
case 1:
// 1st test
// Buffer Data and file extension are correct.
if (dataType.iConfidence == KConfCertain)
{
iTestStepResult = EPass;
}
else
{
INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfCertain"), &confidence);
}
break;
case 2:
// 2nd test
// Buffer data is correct, but the file extension is incorrect.
if (dataType.iConfidence >= KConfProbable)
{
iTestStepResult = EPass;
}
else
{
INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfProbable"), &confidence);
}
break;
case 0:
// 3rd test
// Buffer data is unknown and file extension exists.
if (dataType.iConfidence >= KConfPossible)
{
iTestStepResult = EPass;
}
else
{
INFO_PRINTF2(_L("Returned Wrong Confidence Value: %S, expected KConfPossible"), &confidence);
}
break;
default:
// Safe Guard: This must never happen
break;
}
}
else
{
TBuf<KMaxDataTypeLength> returned;
returned.Copy(dataType.iDataType.Des());
INFO_PRINTF2(_L("- wrong returned MIME-type: %S"), &returned);
iTestStepResult = EFail;
}
return iTestStepResult;
}
//
// OOM Tests
//
/*
**
*/
RTestStepMMRUFOOM* RTestStepMMRUFOOM::NewL(const TTestSpec* aTestSpec)
{
return new(ELeave) RTestStepMMRUFOOM(aTestSpec);
}
/*
**
*/
RTestStepMMRUFOOM::RTestStepMMRUFOOM(const TTestSpec* aTestSpec)
:iTestSpec(aTestSpec)
{
ASSERT(iTestSpec != NULL);
_LIT(KAllocTestStep, "MM-MMF-MMRUF-U-%04d-CP");
TBuf<KTestStepNameSize> temp;
temp.Zero();
temp.AppendFormat(KAllocTestStep, iTestSpec->iTestNumber);
iTestStepName = temp;
}
/*
**
*/
TVerdict RTestStepMMRUFOOM::DoTestStepPreambleL()
{
User::LeaveIfError(iAppArc.Connect());
return EPass;
}
/*
**
*/
TVerdict RTestStepMMRUFOOM::DoTestStepPostambleL()
{
iAppArc.Close();
return EPass;
}
/*
**
*/
TVerdict RTestStepMMRUFOOM::DoTestStepL()
{
TInt err;
TDataRecognitionResult dataType;
TPtrC filename(iTestSpec->iFileName);
RFile file;
TInt failCount = 1;
TBool completed;
TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging
iTestStepResult = EFail;
err = file.Open(iAppArc.FileServer(), filename, EFileRead | EFileShareAny);
if (err != KErrNone)
{
INFO_PRINTF2(_L("RFile.Open() failed: %d"), err);
User::Leave(err);
}
CleanupClosePushL(file);
FOREVER
{
__UHEAP_SETFAIL(RHeap::EFailNext ,failCount);
iTestStepResult = EFail;
// We will check 1000 Allocations as this is a non leaving function.
err = iAppArc.Recognise(file, dataType);
if (err != KErrNone)
{
INFO_PRINTF2(_L("RApaLsSession.RecognizeData() failed: %d"), err);
iTestStepResult = EInconclusive;
}
completed = EFalse;
if (err == KErrNone)
{
if (iTestStepResult == EPass)
{
TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test
if (testAlloc==NULL)
{
reachedEnd = ETrue;
failCount--; // -= 1;
}
else
{
User::Free(testAlloc);
}
completed = reachedEnd;
}
else
{
// the test failed but we have already proved above
// that the required plugins are present
// therefore we assume that the interface returned
// a NULL pointer and so we can continue to test
// until the timeout or the fail count exceeds
completed = EFalse;
}
}
else if (err == KErrNotSupported)
{
// the test has returned not supported but we already
// know that the interface *is* supported so we assume
// that the interface creation failed due to lack of
// memory and so we continue to test until the timeout
// or we exceed the fail count
completed = EFalse;
}
else if (err != KErrNoMemory) // bad error code
{
completed = ETrue;
}
__UHEAP_SETFAIL(RHeap::ENone ,0);
// if we have completed successfully or we have exceeded
// a 1000 failed ALLOC attempts then quit
if (completed || failCount > 1000)
{
break; // exit loop
}
failCount++;
}
// finished with test
CleanupStack::Pop(); //file
if (err != KErrNone)
{
INFO_PRINTF3(_L(" Error(%d) with %d memory allocations tested"), err, failCount);
User::LeaveIfError(err);
}
else
{
INFO_PRINTF2(_L(" Completed OK with %d memory allocations tested"), failCount);
iTestStepResult = EPass;
}
TPtrC8 resMime(dataType.iDataType.Des8());
TPtrC8 expectedMime(iTestSpec->iExpectedMimeType);
TBuf<KMaxDataTypeLength> returned;
returned.Copy(dataType.iDataType.Des());
if (expectedMime.Compare(resMime) == 0)
{
INFO_PRINTF2(_L("Matched Expected MIME-type: %S"), &returned);
iTestStepResult = EPass;
}
else
{
INFO_PRINTF2(_L("- wrong returned MIME-type: %S"), &returned);
iTestStepResult = EFail;
}
INFO_PRINTF1(_L("finished with this test step"));
// test steps return a result
return iTestStepResult;
}