// Copyright (c) 2007-2010 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:
//
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "tcmd_step_resourcereader.h"
#include <ssm/ssmcommandlistresourcereader.h>
#include <ssm/ssmcommandlist.h>
#include <barsc2.h>
#include <barsread2.h>
#include "testcmdlistids.hrh"
#include "ssmcommandlistresourcereaderimpl.h"
#include "ssmpanic.h"
#include "ssmcommandparameters.h"
#include "ssmcommandfactory.h"
#include "ssmatest_utils.h"
#include <e32debug.h>
static const TUint KSwpKey = {12};
class CActiveSchedulerWithRunLCount : public CActiveScheduler
{
public:
void Start();
void Start(TInt aRunLCount);
private:
void WaitForAnyRequest();
private:
TInt iRunLCount;
TBool iCanStopEarly;
};
void CActiveSchedulerWithRunLCount::Start()
{
iCanStopEarly = EFalse;
CActiveScheduler::Start();
}
void CActiveSchedulerWithRunLCount::Start(TInt aRunLCount)
{
iCanStopEarly = ETrue;
iRunLCount = aRunLCount;
CActiveScheduler::Start();
}
void CActiveSchedulerWithRunLCount::WaitForAnyRequest()
{
if (iCanStopEarly && !--iRunLCount)
{
Stop();
}
CActiveScheduler::WaitForAnyRequest();
}
static TInt StopSchedulerCallBack(TAny* /*aNotUsed*/)
{
CActiveScheduler::Current()->Stop();
return KErrNone;
}
CResourceReaderTest::~CResourceReaderTest()
{
delete iAsyncStopScheduler;
delete iActiveScheduler;
iFs.Close();
}
CResourceReaderTest::CResourceReaderTest()
: iWhichPrepare(EPrepareNoCheck)
{
SetTestStepName(KTResourceReader);
iMainThreadId = RThread().Id();
}
/** */
TVerdict CResourceReaderTest::doTestStepPreambleL()
{
INFO_PRINTF1(_L("*** >CResourceReaderTest::doTestStepPreambleL"));
iActiveScheduler = new(ELeave) CActiveSchedulerWithRunLCount;
CActiveScheduler::Install(iActiveScheduler);
iAsyncStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle);
TCallBack stop(StopSchedulerCallBack, NULL);
iAsyncStopScheduler->Set(stop);
SsmCommandFactory::DelegateTo(this); // allows this test code to hook command construction
User::LeaveIfError(iFs.Connect());
User::LeaveIfError(iFs.ShareAuto()); // allows all threads in this process to use this file server session
INFO_PRINTF1(_L("*** CResourceReaderTest::doTestStepPreambleL>"));
return CTestStep::doTestStepPreambleL();
}
/** */
TVerdict CResourceReaderTest::doTestStepPostambleL()
{
INFO_PRINTF1(_L("*** >CResourceReaderTest::doTestStepPostambleL"));
INFO_PRINTF1(_L("*** CResourceReaderTest::doTestStepPostambleL>"));
return CTestStep::doTestStepPostambleL();
}
TBool CResourceReaderTest::ConditionalCommandAllowedL(CResourceFile& aResourceFile, TInt aResourceId)
{
INFO_PRINTF1(_L("*** >CResourceReaderTest::ConditionalCommandAllowedL"));
RResourceReader reader;
reader.OpenLC(&aResourceFile, aResourceId);
const TInt32 softwareReason = reader.ReadInt32L();
const TInt32 hardwareReason = reader.ReadInt32L();
CleanupStack::PopAndDestroy(&reader);
TBool ret = EFalse;
if (softwareReason == EUnconditionalSoftwareReason)
{
ret = ETrue;
}
INFO_PRINTF1(_L("*** CResourceReaderTest::ConditionalCommandAllowedL>"));
return ret;
}
TVerdict CResourceReaderTest::doTestStepL()
{
INFO_PRINTF1(_L("*** >CResourceReaderTest::doTestStepL"));
// Launch the different test cases
TestConstructCases();
TestInitialiseCases();
TestPrepareCases();
TestCancelCases();
TestDelayCases();
TestGetCases();
// this test raises panics due to negative testing - close them to clear the screen.
CloseAllPanicWindowsL();
INFO_PRINTF1(_L("*** CResourceReaderTest::doTestStepL>"));
return TestStepResult();
}
/**
Old Test CaseID AFSS-CMDRSC-0001
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestConstructCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestConstruct1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestConstruct2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestOOM1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestOOM2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
/**
Old Test CaseID AFSS-CMDRSC-0002
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestInitialiseCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestInitialise1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise3L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise4L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise5L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise6L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise7L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise8L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise9L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise10L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise11L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise12L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise13L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise14L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestInitialise15L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestNoMappings1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestNoMappings2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
/**
Old Test CaseID AFSS-CMDRSC-0003
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestPrepareCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestPrepare1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare3L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare4L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare5L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare6L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare7L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare8L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare9L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare10L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare11L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare12L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare13L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare14L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare15L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare16L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestPrepare17L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
/**
Old Test CaseID AFSS-CMDRSC-0004
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestCancelCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestCancel1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestCancel2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
/**
Old Test CaseID AFSS-CMDRSC-0005
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestDelayCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestDelay1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestDelay2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
void CResourceReaderTest::TestConstruct1L()
{
INFO_PRINTF1(_L("*** Starting TestConstruct1L"));
CSsmCommandListResourceReaderImpl* reader = NULL;
TRAPD(err, reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KNullDesC, *this));
delete reader;
TEST(err == KErrArgument);
}
/**
Old Test CaseID AFSS-CMDRSC-0006
New Test CaseID DEVSRVS-SSMA-CMD-0016
*/
void CResourceReaderTest::TestGetCases()
{
TInt err = KErrNone;
__UHEAP_MARK;
TRAP(err, TestGet1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGet2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGet3L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGet4L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGet5L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGeneral1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestCommandType1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGetCommandListIds1L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGetCommandListIds2L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
__UHEAP_MARK;
TRAP(err, TestGetCommandListIds3L());
TEST(err == KErrNone);
__UHEAP_MARKEND;
}
// simple valid construct followed by delete, should not leave or leak memory
void CResourceReaderTest::TestConstruct2L()
{
INFO_PRINTF1(_L("*** Starting TestConstruct2L"));
_LIT(KValidCommandListPath, "z:\\resource\\ssmatest\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KValidCommandListPath, *this);
delete reader;
}
// initialise should fail with KErrNotFound after passing a bad path to NewL
void CResourceReaderTest::TestInitialise1L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest directory that does not exist\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrPathNotFound);
delete reader;
}
// Call Init, fails with KErrNotFound as directory doesn't contain any command list resource files
void CResourceReaderTest::TestInitialise2L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNotFound);
delete reader;
}
// Call Init twice using the same TRequestStatus object without waiting for the first init to complete.
// 2nd init should panic with EInUse1.
// The only option for the resource reader when this happens is to panic, as it cannot
// return the error from the second init using the first init's request status.
void CResourceReaderTest::TestInitialise3L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise3L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadInitialise3);
TEST(exitReason == EInUse1);
}
void CResourceReaderTest::ThreadInitialise3L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
reader->Initialise(status); // panic is only thing to do when same status is used on 2 calls to init
delete reader;
}
// Successful init followed by another call to Init should not give error
void CResourceReaderTest::TestInitialise4L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise4L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// first init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone); // successful init
// second init
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone); // successful init
delete reader;
}
// Init using a resource file with invalid version number should complete with error.
void CResourceReaderTest::TestInitialise5L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise5L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNotSupported);
delete reader;
}
// Prepare state list on uninitialised reader should panic
void CResourceReaderTest::TestInitialise6L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise6L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadInitialise6);
TEST(exitReason == ENotInitialized);
}
void CResourceReaderTest::ThreadInitialise6L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
TSsmState state;
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
delete reader;
}
// Prepare swp list on uninitialised reader should panic
void CResourceReaderTest::TestInitialise7L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise7L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadInitialise7);
TEST(exitReason == ENotInitialized2);
}
void CResourceReaderTest::ThreadInitialise7L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
TSsmSwp swp(0, 0);
reader->PrepareCommandList(*this, ETestCommandListId1, swp, status); // should panic with ENotInitialized2
delete reader;
}
// Get command list on uninitialised reader should panic
void CResourceReaderTest::TestInitialise8L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise8L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadInitialise8);
TEST(exitReason == ENoPreparedCommandList);
}
void CResourceReaderTest::ThreadInitialise8L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
reader->GetCommandList(); // should panic with ENoPreparedCommandList
delete reader;
}
// Prepare state list on uninitialised reader (after init fail) should panic
void CResourceReaderTest::TestInitialise9L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise9L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadInitialise9);
TEST(exitReason == ENotInitialized);
}
void CResourceReaderTest::ThreadInitialise9L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists1\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
CleanupStack::PushL(reader);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNotSupported);
// init has failed, prepare a command list
TSsmState state;
reader->PrepareCommandList(*this, ETestCommandListId1, state, status); // should panic with ENotInitialized
CleanupStack::PopAndDestroy(reader);
}
// delete after 1 Init RunL should cause no error
void CResourceReaderTest::TestInitialise10L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise10L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status); // this init should be split into 3 RunLs
TEST(status == KRequestPending);
Run(1);
delete reader; // should complete status
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
}
// delete after 2 Init RunLs should cause no error
void CResourceReaderTest::TestInitialise11L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise11L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status); // this init should be split into 3 RunLs
TEST(status == KRequestPending);
Run(2);
delete reader; // should complete status
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
}
// cancel init before it can RunL - check completes with KErrCancel and no error/mem leak on delete
void CResourceReaderTest::TestInitialise12L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise12L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
// cancel init, should complete status with KErrCancel
reader->InitialiseCancel();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
delete reader;
}
// cancel init after 1 RunL - check completes with KErrCancel and no error/mem leak on delete
void CResourceReaderTest::TestInitialise13L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise13L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run(1);
// cancel init after only 1 RunL (3 required to complete init), should complete status with KErrCancel
reader->InitialiseCancel();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
delete reader;
}
// cancel init after 2 RunLs - check completes with KErrCancel and no error/mem leak on delete
void CResourceReaderTest::TestInitialise14L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise14L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run(2);
// cancel init after only 2 RunLs (3 required to complete init), should complete status with KErrCancel
reader->InitialiseCancel();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
delete reader;
}
// cancel init before it can RunL - check no error, then init again without cancel - should init ok
void CResourceReaderTest::TestInitialise15L()
{
INFO_PRINTF1(_L("*** Starting TestInitialise15L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
// cancel init, should complete status with KErrCancel
reader->InitialiseCancel();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
// init again (without cancel) - should complete with KErrNone (even after previous cancel)
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
delete reader;
}
// delete immediately after prepare should cause no error
void CResourceReaderTest::TestPrepare1L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
delete reader; // should complete status
User::WaitForRequest(status);
TEST(status == KErrCancel);
}
// delete after only 1 prepare RunL - should cause no error
void CResourceReaderTest::TestPrepare2L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(1);
TEST(status == KRequestPending); // should be still pending as 1 RunL isn't enough to complete the prepare
delete reader; // should complete status
User::WaitForRequest(status);
TEST(status == KErrCancel);
}
// delete after only 2 prepare RunLs - should cause no error
void CResourceReaderTest::TestPrepare3L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare3L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(2);
TEST(status == KRequestPending); // should be still pending as 2 RunLs isn't enough to complete the prepare
delete reader; // should complete status
User::WaitForRequest(status);
TEST(status == KErrCancel);
}
// after 3 RunLs, prepare should be completed with KErrNone.
// deleting shouldn't complete again with KErrCancel.
void CResourceReaderTest::TestPrepare4L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare4L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(3);
User::WaitForRequest(status);
TEST(status == KErrNone); // 1st RunL initial step, 2nd prepare 5 commands, 3rd prepares last 5 commands, so after 3 RunLs, a list of 10 commands should be complete
delete reader; // should not complete status with KErrCancel
TEST(status == KErrNone);
}
// check command list is "ready" after a prepare and
// no longer ready after calling IsCommandListReady a second time
void CResourceReaderTest::TestPrepare5L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare5L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
// check command list status
TEST(reader->IsCommandListReady());
TEST(!reader->IsCommandListReady());
TEST(!reader->IsCommandListReady());
delete reader;
}
// cancel prepare before it can RunL - check no error
void CResourceReaderTest::TestPrepare6L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare6L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// cancel prepare before it can RunL, should complete status with KErrCancel
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
reader->PrepareCommandListCancel();
User::WaitForRequest(status);
TEST(status == KErrCancel);
delete reader;
}
// cancel prepare after only 1 RunL - check no error
void CResourceReaderTest::TestPrepare7L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare7L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// cancel prepare after 1 RunL, should complete status with KErrCancel
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(1);
TEST(status == KRequestPending);
reader->PrepareCommandListCancel();
User::WaitForRequest(status);
TEST(status == KErrCancel);
delete reader;
}
// cancel prepare after only 2 RunLs - check no error
void CResourceReaderTest::TestPrepare8L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare8L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// cancel prepare after 2 RunLs, should complete status with KErrCancel
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(2);
TEST(status == KRequestPending);
reader->PrepareCommandListCancel();
User::WaitForRequest(status);
TEST(status == KErrCancel);
delete reader;
}
// cancel once fully prepared shouldn't complete with KErrCancel
void CResourceReaderTest::TestPrepare9L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare9L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
reader->PrepareCommandListCancel();
TEST(status == KErrNone); // still KErrNone, as request has already completed
delete reader;
}
// cancel during prepare followed by another prepare, should work ok
void CResourceReaderTest::TestPrepare10L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare10L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// first prepare, cancel part way through
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(2);
reader->PrepareCommandListCancel();
User::WaitForRequest(status);
TEST(status == KErrCancel);
// second prepare, allow this one to complete normally
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone); // should complete ok, even though previous prepare was cancelled
delete reader;
}
// empty command list resource should return an empty command list
void CResourceReaderTest::TestPrepare11L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare11L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone); // preparing an empty command list is not an error
CSsmCommandList* commandList = reader->GetCommandList();
TEST(commandList->Count() == 0); // should be empty
delete commandList;
commandList = NULL;
delete reader;
}
// Prepare 2 command lists one after the other, check both are returned by GetCommandList without error
void CResourceReaderTest::TestPrepare12L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare12L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
CSsmCommandList* commandList = reader->GetCommandList();
TEST(commandList->Count() == 0);
delete commandList;
commandList = NULL;
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
commandList = reader->GetCommandList();
TEST(commandList->Count() == 0);
delete commandList;
commandList = NULL;
delete reader;
}
// prepare for id not found, then prepare for an ID found, checks
// the notFound doesn't stop further prepares being attempted
void CResourceReaderTest::TestPrepare13L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare13L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId2, state, status); // ETestCommandListId2 not present in cmdlists5.rss
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNotFound);
TEST(!reader->IsCommandListReady());
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone); // prepare worked ok even though previous prepare failed
TEST(reader->IsCommandListReady());
delete reader;
}
// prepare, cancel, then IsCommandListReady, should return false
void CResourceReaderTest::TestPrepare14L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare14L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// cancel prepare after 2 RunLs, should complete status with KErrCancel
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run(2);
TEST(status == KRequestPending);
reader->PrepareCommandListCancel();
User::WaitForRequest(status);
TEST(status == KErrCancel);
TEST(!reader->IsCommandListReady());
delete reader;
}
// use factory callback to leave during list prepare, then prepare again to
// check it works 2nd time
void CResourceReaderTest::TestPrepare15L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare15L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
iWhichPrepare = EPrepareLeave;
Run();
User::WaitForRequest(status);
TEST(status == KErrGeneral);
// prepare again to check it works after leaving during the last prepare
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
iWhichPrepare = EPrepareNoCheck;
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
delete reader;
}
// Init, cancel before init starts processing, then prepare should panic with "NotInitialised"
void CResourceReaderTest::TestPrepare16L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare16L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadPrepare16);
TEST(exitReason == ENotInitialized);
}
void CResourceReaderTest::ThreadPrepare16L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
reader->InitialiseCancel();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrCancel);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status); // should panic
Run();
User::WaitForRequest(status);
delete reader;
}
// Check ConditionalCommandAllowedL is not executed when cmds get constructed
void CResourceReaderTest::TestPrepare17L()
{
INFO_PRINTF1(_L("*** Starting TestPrepare17L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists6\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare - only 2 of the 3 commands would be executed
// however all 3 should be included in the command list
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
iWhichPrepare = EConditional;
iCommandConstructCount = 0;
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
TEST(iCommandConstructCount == 3);
iWhichPrepare = EPrepareNoCheck;
delete reader;
}
// 2 cancels one after the other on uninitialised reader
void CResourceReaderTest::TestCancel1L()
{
INFO_PRINTF1(_L("*** Starting TestCancel1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
reader->InitialiseCancel();
reader->InitialiseCancel();
delete reader;
}
// 2 cancels one after the other on initialised reader
void CResourceReaderTest::TestCancel2L()
{
INFO_PRINTF1(_L("*** Starting TestCancel2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// cancel with no operation in progress
reader->InitialiseCancel();
TEST(status == KErrNone);
reader->InitialiseCancel();
TEST(status == KErrNone);
delete reader;
}
// GetCommandList before init
void CResourceReaderTest::TestGet1L()
{
INFO_PRINTF1(_L("*** Starting TestGet1L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadGet1);
TEST(exitReason == ENoPreparedCommandList);
}
void CResourceReaderTest::ThreadGet1L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
CSsmCommandList* commandList = reader->GetCommandList(); // should panic as a command list hasn't been prepared
commandList = NULL;
delete reader;
}
// get cmd list after prepare, then get again should panic
void CResourceReaderTest::TestGet2L()
{
// NOTE - This test (and others)use an empty command list resource (provided by cmdlists5.rss) to ensure the reader
// doesn't try to construct any commands. Any attempt to construct commands
// in this test code using CSsmCommandListResourceReader would result in
// NULL being returned by CResourceReaderTest::ConstructCommandFromResourceLC
// and the NULL being passed to the "real" command list AppendL method, ie. CSsmCommandListImpl::AppendL
// CSsmCommandListImpl::AppendL expects a non-NULL pointer to be passed to it.
INFO_PRINTF1(_L("*** Starting TestGet2L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadGet2);
TEST(exitReason == ENoPreparedCommandList);
}
void CResourceReaderTest::ThreadGet2L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
CSsmCommandList* commandList = reader->GetCommandList(); // should be ok
delete commandList;
commandList = NULL;
commandList = reader->GetCommandList(); // should panic as GetCommandList has already returned ownership of the command list
commandList = NULL;
delete reader;
}
// prepare ok, then start prepare again, but before complete, try to get - should panic
void CResourceReaderTest::TestGet3L()
{
INFO_PRINTF1(_L("*** Starting TestGet3L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadGet3);
TEST(exitReason == ENoPreparedCommandList);
}
void CResourceReaderTest::ThreadGet3L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
// prepare again before getting command list
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
CSsmCommandList* commandList = reader->GetCommandList(); // should panic as a new prepare has just been initiated
delete commandList;
commandList = NULL;
delete reader;
}
// get cmd list after prepare - should work ok
void CResourceReaderTest::TestGet4L()
{
INFO_PRINTF1(_L("*** Starting TestGet4L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
CSsmCommandList* commandList = reader->GetCommandList(); // should return prepared command list
TEST(commandList->Count() == 0);
delete commandList;
commandList = NULL;
delete reader;
}
// Init using 1 resource file that contains an empty mapping array.
// Init should complete with KErrNotFound.
void CResourceReaderTest::TestNoMappings1L()
{
INFO_PRINTF1(_L("*** Starting TestNoMappings1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists2\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNotFound);
delete reader;
}
// Init using 1 resource file whose mapping LLINK is zero.
// Init should complete with KErrNotFound.
void CResourceReaderTest::TestNoMappings2L()
{
INFO_PRINTF1(_L("*** Starting TestNoMappings2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists4\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNotFound);
delete reader;
}
// check 2 resource files are loaded by requesting a list from each
// checks state and swp are passed to factory method correctly
void CResourceReaderTest::TestGeneral1L()
{
INFO_PRINTF1(_L("*** Starting TestGeneral1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// Prepare cmd list from first resource file
TSsmState state(0,23);
iWhichPrepare = EPrepareState;
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
// Prepare cmd list from second resource file
TSsmSwp swp(KSwpKey, 24);
iWhichPrepare = EPrepareSwp;
reader->PrepareCommandList(*this, ETestCommandListId2, swp, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
delete reader;
iWhichPrepare = EPrepareNoCheck;
}
// check default delay value is read from resource ok
void CResourceReaderTest::TestDelay1L()
{
INFO_PRINTF1(_L("*** Starting TestDelay1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// Prepare cmd list with no delay specified
const TInt KNonZeroValue = 1;
iDelay = KNonZeroValue;
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
const TInt KExpectedDelay = 0;
TEST(iDelay == KExpectedDelay);
delete reader;
}
// check specific delay value is read from resource ok
// uses a "real" reader and command list to check the command list contains the correct value
void CResourceReaderTest::TestDelay2L()
{
INFO_PRINTF1(_L("*** Starting TestDelay2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists5\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
CSsmCommandList* commandList = reader->GetCommandList(); // should return prepared command list
const TInt KExpectedDelay = 12;
const TInt actualDelay = commandList->DelayBetweenCommands();
TEST(actualDelay == KExpectedDelay);
delete commandList;
commandList = NULL;
delete reader;
}
// check the expected command type is readable by the RResourceReader provided to ConstructCommandFromResourceLC via the TSsmCommandParameters parameter
void CResourceReaderTest::TestCommandType1L()
{
INFO_PRINTF1(_L("*** Starting TestCommandType1L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
TSsmState state(0,23);
iWhichPrepare = EPrepareType;
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
TEST(status == KErrNone);
delete reader;
iWhichPrepare = EPrepareNoCheck;
}
// Get command list ids before init should cause a panic
void CResourceReaderTest::TestGetCommandListIds1L()
{
INFO_PRINTF1(_L("*** Starting TestGetCommandListIds1L"));
const TInt exitReason = StartTestInThreadL(TThreadParams::EThreadGetCommandListIds1);
TEST(exitReason == ENotInitialized3);
}
void CResourceReaderTest::ThreadGetCommandListIds1L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
CleanupStack::PushL(reader);
RArray<TInt> array;
CleanupClosePushL(array);
reader->GetCommandListIdsL(array); // should panic as reader hasn't been initialised
CleanupStack::PopAndDestroy(&array);
CleanupStack::PopAndDestroy(reader);
}
// check calling GetCommandListIdsL passing a non-empty array leaves with KErrArgument
void CResourceReaderTest::TestGetCommandListIds2L()
{
INFO_PRINTF1(_L("*** Starting TestGetCommandListIds2L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
CleanupStack::PushL(reader);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
RArray<TInt> array;
CleanupClosePushL(array);
array.AppendL(ETestCommandListId1); // make array non-empty
TRAPD(err, reader->GetCommandListIdsL(array)); // should leave with KErrArgument
TEST(err == KErrArgument);
CleanupStack::PopAndDestroy(&array);
CleanupStack::PopAndDestroy(reader);
}
// check GetCommandListIdsL returns the correct command list ids
void CResourceReaderTest::TestGetCommandListIds3L()
{
INFO_PRINTF1(_L("*** Starting TestGetCommandListIds3L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
CleanupStack::PushL(reader);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
RArray<TInt> array;
CleanupClosePushL(array);
reader->GetCommandListIdsL(array);
array.FindL(ETestCommandListId1); // should not leave with KErrNotFound
array.FindL(ETestCommandListId2); // should not leave with KErrNotFound
TRAPD(err, array.FindL(ETestCommandListId3)); // ETestCommandListId3 should not be found
TEST(err == KErrNotFound);
CleanupStack::PopAndDestroy(&array);
CleanupStack::PopAndDestroy(reader);
}
// check attempt to construct reader under low memory conditions doesn't leak memory
void CResourceReaderTest::TestOOM1L()
{
INFO_PRINTF1(_L("*** Starting TestOOM1L"));
TInt failRate = 1;
for (;;failRate++)
{
__UHEAP_RESET;
__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
__UHEAP_MARK;
TRAPD(ret, DoOOM1L());
TEST((ret==KErrNone || ret==KErrNoMemory));
__UHEAP_MARKEND;
if (ret==KErrNone)
{
break;
}
}
__UHEAP_RESET;
INFO_PRINTF2(_L(" #allocs for CSsmCommandListResourceReader::NewL: %d."),failRate-1);
}
void CResourceReaderTest::DoOOM1L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReader* reader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath, *this);
delete reader;
}
// check out of memory conditions during command list reader init/prepare don't cause memory to be leaked
void CResourceReaderTest::TestOOM2L()
{
INFO_PRINTF1(_L("*** Starting TestOOM2L"));
TInt failRate = 1;
for (;;failRate++)
{
__UHEAP_RESET;
__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
__UHEAP_MARK;
TRAPD(ret, DoOOM2L());
TEST((ret==KErrNone || ret==KErrNoMemory));
__UHEAP_MARKEND;
if (ret==KErrNone)
{
break;
}
}
__UHEAP_RESET;
INFO_PRINTF2(_L(" #allocs for CSsmCommandListResourceReaderImpl init + 2 prepares: %d."),failRate-1);
}
void CResourceReaderTest::DoOOM2L()
{
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists3\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
CleanupStack::PushL(reader);
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
if (status == KErrNoMemory)
{
User::Leave(KErrNoMemory);
}
TEST(status == KErrNone);
// Prepare cmd list from first resource file
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
if (status == KErrNoMemory)
{
User::Leave(KErrNoMemory);
}
TEST(status == KErrNone);
// Prepare cmd list from second resource file
TSsmSwp swp(KSwpKey, 24);
reader->PrepareCommandList(*this, ETestCommandListId2, swp, status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status);
if (status == KErrNoMemory)
{
User::Leave(KErrNoMemory);
}
TEST(status == KErrNone);
CleanupStack::PopAndDestroy(reader);
}
void CResourceReaderTest::Run()
{
if (RThread().Id() != iMainThreadId)
{
iThreadAsyncStopScheduler->CallBack();
iThreadActiveScheduler->Start();
}
else
{
iAsyncStopScheduler->CallBack();
iActiveScheduler->Start();
}
}
void CResourceReaderTest::Run(TInt aRunLCount)
{
if (RThread().Id() != iMainThreadId)
{
iThreadActiveScheduler->Start(aRunLCount);
}
else
{
iActiveScheduler->Start(aRunLCount);
}
}
TInt CResourceReaderTest::StartTestInThreadL(TThreadParams::TFunction aFunction)
{
// Tests that should panic, are run in a separate thread so we can check the panic category and code
RThread thread;
// Give each thread a unique name to avoid KErrAlreadyExists error on thread creation
_LIT(KThreadNamePrefix, "SsmTestThread");
RBuf threadName;
CleanupClosePushL(threadName);
threadName.CreateL(KThreadNamePrefix().Length() + 4); // 4 digit thread number
threadName = KThreadNamePrefix;
threadName.AppendNumFixedWidth(aFunction, EDecimal, 4);
TThreadParams params(*this, aFunction);
const TInt KMinHeapSize = 0xc800; // 50k - NOTE just an arbitrary value, please feel free to change it
const TInt KMaxHeapSize = 0x19000; // 100k - NOTE just an arbitrary value, please feel free to change it
User::LeaveIfError(thread.Create(threadName, ThreadStartFn, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, ¶ms));
CleanupStack::PopAndDestroy(&threadName);
TRequestStatus status;
thread.Logon(status);
thread.Resume();
User::WaitForRequest(status);
TExitCategoryName category = thread.ExitCategory();
RDebug::Print(_L("***** Exit Category = %S *****"),&category);
TEST(category.Compare(KPanicCmdResourceReader) == 0); // always expecting a resource reader panic
const TInt exitReason = thread.ExitReason();
thread.Close();
return exitReason;
}
TInt CResourceReaderTest::ThreadStartFn(TAny* aPtr)
{
CTrapCleanup* trapCleanup = CTrapCleanup::New();
if (!trapCleanup)
{
return KErrNoMemory;
}
TThreadParams& threadParams = *(reinterpret_cast<TThreadParams*>(aPtr));
TRAPD(err, threadParams.iTestStep.ThreadDoTestL(threadParams.iFunction));
delete trapCleanup;
return err;
}
void CResourceReaderTest::ThreadDoTestL(TThreadParams::TFunction aFunction)
{
CActiveSchedulerWithRunLCount* activeScheduler = new(ELeave) CActiveSchedulerWithRunLCount;
CleanupStack::PushL(activeScheduler);
CActiveScheduler::Install(activeScheduler);
CAsyncCallBack* threadAsyncStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle);
TCallBack stop(StopSchedulerCallBack, NULL);
threadAsyncStopScheduler->Set(stop);
CleanupStack::Pop(activeScheduler);
iThreadActiveScheduler = activeScheduler;
iThreadAsyncStopScheduler = threadAsyncStopScheduler;
TRAPD(err, ThreadDispatchFunctionL(aFunction));
delete iThreadAsyncStopScheduler;
iThreadAsyncStopScheduler = NULL;
delete iThreadActiveScheduler;
iThreadActiveScheduler = NULL;
User::LeaveIfError(err);
}
void CResourceReaderTest::ThreadDispatchFunctionL(TThreadParams::TFunction aFunction)
{
switch (aFunction)
{
case TThreadParams::EThreadInitialise3:
ThreadInitialise3L();
break;
case TThreadParams::EThreadInitialise6:
ThreadInitialise6L();
break;
case TThreadParams::EThreadInitialise7:
ThreadInitialise7L();
break;
case TThreadParams::EThreadInitialise8:
ThreadInitialise8L();
break;
case TThreadParams::EThreadInitialise9:
ThreadInitialise9L();
break;
case TThreadParams::EThreadGet1:
ThreadGet1L();
break;
case TThreadParams::EThreadGet2:
ThreadGet2L();
break;
case TThreadParams::EThreadGet3:
ThreadGet3L();
break;
case TThreadParams::EThreadPrepare16:
ThreadPrepare16L();
break;
case TThreadParams::EThreadGetCommandListIds1:
ThreadGetCommandListIds1L();
break;
default:
TEST(EFalse); // invalid TFunction provided
break;
}
}
void CResourceReaderTest::AppendL(MSsmCommand* /*aCmd*/)
{
}
TArray<MSsmCommand*> CResourceReaderTest::PendingDeferred() const
{
RPointerArray<MSsmCommand> array;
return array.Array();
}
void CResourceReaderTest::SetDelayBetweenCommands(TInt aDelayBetweenCommands)
{
iDelay = aDelayBetweenCommands;
}
void CResourceReaderTest::SetResourceFileNameL(const TDesC& /*aFileName*/)
{
}
void CResourceReaderTest::SetConditionalCallback(MSsmConditionalCallback& /*aCallBack*/)
{
}
CSsmCommandBase* CResourceReaderTest::ConstructCommandFromResourceLC(TSsmCommandType aType, TSsmCommandParameters& aCommandParameters)
{
switch (iWhichPrepare)
{
case EPrepareNoCheck: // don't perform any checks
break;
case EPrepareState:
TEST(aCommandParameters.StateL().Int() == 23);
break;
case EPrepareSwp:
TEST(aCommandParameters.SwpL() == TSsmSwp(KSwpKey, 24));
break;
case EPrepareLeave:
INFO_PRINTF1(_L("Leaving from CResourceReaderTest::ConstructCommandFromResourceLC with KErrGeneral"));
User::Leave(KErrGeneral);
break;
case EConditional:
++iCommandConstructCount;
break;
case EPrepareType:
{
RResourceReader& reader = aCommandParameters.MainReader();
const TSsmCommandType type = static_cast<TSsmCommandType>(reader.ReadInt16L());
TEST(type == aType);
}
break;
default:
User::Invariant(); // should never get here
break;
}
CSsmCommandBase* cmd = NULL;
CleanupStack::PushL(cmd);
return NULL;
}
/*
It tests for the scenario where first file have no commands(i.e. cmdlists7a) and second file cmdlists7b have two commands and
third file have no commands(i.e cmdlists7c)
CommandList should be created and iCommandConstructCount should be two.
*/
void CResourceReaderTest::TestGet5L()
{
INFO_PRINTF1(_L("*** Starting TestGet5L"));
_LIT(KCommandListPath, "z:\\resource\\ssmatest\\cmdlists7\\");
CSsmCommandListResourceReaderImpl* reader = CSsmCommandListResourceReaderImpl::NewL(iFs, KCommandListPath, *this);
// init
TRequestStatus status;
reader->Initialise(status);
TEST(status == KRequestPending);
Run();
User::WaitForRequest(status); // mop up the completed initialisation request
TEST(status == KErrNone);
// prepare
TSsmState state(0,23);
reader->PrepareCommandList(*this, ETestCommandListId1, state, status);
iWhichPrepare = EConditional;
iCommandConstructCount = 0;
Run();
User::WaitForRequest(status);
TBool commandListReady = reader->IsCommandListReady();
TEST((status == KErrNone) && (commandListReady == TRUE) && (iCommandConstructCount == 2));
iWhichPrepare = EPrepareNoCheck;
delete reader;
}