/**
MainL()
Description : This is the main function which installs the
active scheduler and creates an object of the Email server
@internalTechnology
@param none
@return none
@pre None
@post None
*/
LOCAL_C void MainL()
{
CActiveScheduler* sched = new (ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
__UHEAP_MARK;
/*
// this registers the server with the active scheduler and calls SetActive
CT_LbsAGPSHAIAssDataServer* server = CT_LbsAGPSHAIAssDataServer::NewL();
*/
CTestServerBase* s = new (ELeave) CTestServerBase();
CleanupStack::PushL(s);
s->ConstructL();
// signal to the client that we are ready by
// rendevousing process
RProcess::Rendezvous(KErrNone);
// run the active scheduler
sched->Start();
CleanupStack::PopAndDestroy(s);
/*
// clean up
delete server;
*/
__UHEAP_MARKEND;
CleanupStack::PopAndDestroy(sched);
}
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
CActiveScheduler::Install(scheduler);
CTrapCleanup* cleanup = CTrapCleanup::New();
if (!cleanup)
{
return KErrNoMemory;
}
CTLbsNetworkGateway* networkGateway = 0;
TRAPD(err, networkGateway = CTLbsNetworkGateway::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
scheduler->Start();
}
if (KErrNone == err)
{
delete networkGateway;
}
delete cleanup;
delete scheduler;
__UHEAP_MARKEND;
return err;
}
LOCAL_C void MainL ()
{
// For platform security
#if ( defined __DATA_CAGING__ )
RProcess ().DataCaging ( RProcess::EDataCagingOn );
RProcess ().SecureApi ( RProcess::ESecureApiOn );
#endif
CActiveScheduler* sched = NULL;
sched = new ( ELeave ) CActiveScheduler;
CActiveScheduler::Install ( sched );
CChunkMgrTestSuite* server = NULL;
// Create the test-server
TRAPD ( err, server = CChunkMgrTestSuite::NewL () );
if ( !err )
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous ( KErrNone );
sched->Start ();
}
delete server;
delete sched;
}
// Secure variants much simpler
// For EKA2, just an E32Main and a MainL()
LOCAL_C void MainL()
/**
* Secure variant
* Much simpler, uses the new Rendezvous() call to sync with the client
*/
{
// Leave the hooks in for platform security
#if (defined __DATA_CAGING__)
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().DataCaging(RProcess::ESecureApiOn);
#endif
CActiveScheduler* sched = NULL;
sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestImpExvCardSuite* server = NULL;
// Create the CTestServer derived server
TRAPD(err,server = CTestImpExvCardSuite::NewL());
if(!err)
{
RProcess::Rendezvous(KErrNone);
sched->Start();
}
delete server;
delete sched;
}
// -----------------------------------------------------------------------------
// TMSCallServer::StartThreadL
//
// -----------------------------------------------------------------------------
//
void TMSCallServer::StartThreadL(TMSCallServerStartParam& aStart)
{
TRACE_PRN_FN_ENT;
CActiveScheduler* sched = new (ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
TMSCallServer* server = TMSCallServer::NewL(aStart.iTMSServer);
CleanupStack::PushL(server);
//Rename tmscall server name
RThread tmscallServerThread;
TThreadId threadId;
TName name;
name.Append(KTMSCallServerName);
threadId = tmscallServerThread.Id();
name.AppendNum(threadId.Id(), EHex);
//We are ignoring the error code returned from User::RenameThread
//as it is not important here, may be for profiling
User::RenameThread(name);
aStart.iTMSCallServerHandle = server->Server();
// Sync with the client and enter the active scheduler
RThread::Rendezvous(KErrNone);
sched->Start();
CleanupStack::PopAndDestroy(server); // server
CleanupStack::PopAndDestroy(sched); // sched
TRACE_PRN_FN_EXT;
}
LOCAL_C void MainL()
{
// For platform security
#if (defined __DATA_CAGING__)
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().SecureApi(RProcess::ESecureApiOn);
#endif
CActiveScheduler* sched = NULL;
sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestCalInterimApiInstanceSuiteServer* server = NULL;
// Create the test-server
TRAPD(err, server = CTestCalInterimApiInstanceSuiteServer::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
#ifdef __WINS__
// To start the alarm server
server->StartAlarmAlertServer();
#endif
sched->Start();
}
delete server;
delete sched;
}
static void MainL()
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL (sched);
CActiveScheduler::Install (sched);
CCmdTestServer* server = CCmdTestServer::NewLC( );
RProcess::Rendezvous (KErrNone );
sched->Start( );
CleanupStack::PopAndDestroy (server );
CleanupStack::PopAndDestroy (sched );
}
TVerdict CSisRegistryWritableSessionStep::doTestStepPostambleL()
{
// Remove the installed active scheduler
CActiveScheduler* s = CActiveScheduler::Current();
s->Install(NULL);
delete s;
iSisRegistry.Close();
__UHEAP_MARKEND;
return TestStepResult();
}
void MainL()
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
// Create the CTestServer derived server, sync with the client and enter the active scheduler
CAppfwkDSCStoreTestServer* server = CAppfwkDSCStoreTestServer::NewL();
RProcess::Rendezvous(KErrNone);
sched->Start();
delete server;
CleanupStack::PopAndDestroy(sched);
}
TVerdict CSisRegistryWritableSessionStep::doTestStepPostambleL()
{
StopTimerAndPrintResultL();
// Remove the installed active scheduler
CActiveScheduler* s = CActiveScheduler::Current();
s->Install(NULL);
delete s;
INFO_PRINTF1(_L("Disconnecting to SisRegistry.."));
iSisRegistry.Close();
__UHEAP_MARKEND;
return TestStepResult();
}
/////////////////////////////////////////////////////////////////////
// CSisRegistryStep
/////////////////////////////////////////////////////////////////////
TVerdict CSisRegistryWritableSessionStep::doTestStepPreambleL()
{
__UHEAP_MARK;
// Install an active scheduler
CActiveScheduler* s = new (ELeave) CActiveScheduler;
s->Install(s);
INFO_PRINTF1(_L("Connecting to SisRegistry.."));
User::LeaveIfError(iSisRegistry.Connect());
INFO_PRINTF1(_L("Connected!"));
return TestStepResult();
}
static void MainL()
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
// Create the CTestServer derived server
CStartupPropertiesTestServer* server = CStartupPropertiesTestServer::NewLC();
RProcess::Rendezvous(KErrNone);
sched->Start();
CleanupStack::PopAndDestroy(server);
CleanupStack::PopAndDestroy(sched);
}
// ---------------------------------------------------------------------------
// DoStartL
// ---------------------------------------------------------------------------
//
void DoStartL()
{
// Create active scheduler (to run active objects)
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
CSpsBackupHelperMonitor* monitor = CSpsBackupHelperMonitor::NewL();
scheduler->Start();
delete monitor;
// Delete active scheduler
CleanupStack::PopAndDestroy(scheduler);
}
static void MainL()
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install (sched);
CCLayerTestServerWithSsm* server = NULL;
server = CCLayerTestServerWithSsm::NewL();
if(server)
{
RProcess::Rendezvous (KErrNone);
sched->Start();
}
delete server;
CleanupStack::PopAndDestroy();// sched;
}
void CSwiEngine::ThreadFunctionL(CSwiTask* aTask)
{
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
// this will add some active objects to AS...
aTask->WrapTaskL();
// make it do the work
scheduler->Start();
// cleanup the worker thread
CleanupStack::PopAndDestroy(scheduler);
}
/**
MainL - uses the new Rendezvous() call to sync with the client
*/
LOCAL_C void MainL()
{
// Active scheduler only for this thread. Test need to create own active scheduler
CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(scheduler);
CTe_graphicsperformanceSuite* server = NULL;
// Create the CTestServer derived server
TRAPD(err,server = CTe_graphicsperformanceSuite::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
scheduler->Start();
}
delete server;
delete scheduler;
}
/*
Function to create and start the CTestServer derived server.
Secure variant.Much simpler, uses the new Rendezvous() call to sync with the client
@param None
@return None
*/
LOCAL_C void MainL()
{
// Leave the hooks in for platform security
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().DataCaging(RProcess::ESecureApiOn);
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestPnP* server = NULL;
// Create the CTestServer derived server
TRAPD(err,server = CTestPnP::NewL());
if(err == KErrNone)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
sched->Start();
}
delete server;
delete sched;
}
void DriveEngineL()
{
//initialization for COMM port
CommInitL();
// Setup Active Scheduler
CActiveScheduler* myActiveScheduler = new(ELeave) CActiveScheduler;
CleanupStack::PushL(myActiveScheduler);
CActiveScheduler::Install(myActiveScheduler);
// Create Tiny Telnet
CTinyTelnet* aTinyTelnet = CTinyTelnet::NewLC(console);
//.. and post request to object
aTinyTelnet->RequestCharacter();
myActiveScheduler->Start();
CleanupStack::PopAndDestroy(2); //aTinyTelnet, myActiveScheduler
}
void ThreadDispatchSwpInvalidListFunctionL(CSsmValidSwpListTest* aSsmValidSwpListTest)
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler();
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
// Create a swp policy resolver and register our property
CSsmSwpPolicyResolver* resolver = CSsmSwpPolicyResolver::NewL();
CleanupStack::PushL(resolver);
resolver->RegisterSwpMappingL(key, KTestSwpPolicyInvalidListFile);
// Create a cle session proxy
CCleSessionProxy* cleSession = CCleSessionProxy::NewL();
CleanupStack::PushL(cleSession);
cleSession->ConnectL();
// Create the swp request handler and wire it up to the proxies
CSsmSwpRequestHandler* handler = CSsmSwpRequestHandler::NewL();
handler->SetSwpPolicyResolverProxy(resolver);
handler->SetCleSessionProxy(cleSession);
CleanupStack::Pop(cleSession);
CleanupStack::Pop(resolver);
CleanupStack::PushL(handler);
//To get the handle to testssmswppolicyserver, since we have to test the exit reason
if (aSsmValidSwpListTest->Function() == ESwpCmdTooManyMultipleWaitErr1)
aSsmValidSwpListTest->GetSsmSwpPolicyServerThreadIdL();
//Request transition according to the reason action, which will define the invalid list
const TSsmSwp swp(key, aSsmValidSwpListTest->Function());
handler->SubmitRequestL(swp);
sched->Start();
CleanupStack::PopAndDestroy(3, sched);
}
/**
* Secure variant
* Much simpler, uses the new Rendezvous() call to sync with the client
*/
LOCAL_C void MainL()
{
#if (defined __DATA_CAGING__)
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().SecureApi(RProcess::ESecureApiOn);
#endif
CActiveScheduler* sched = NULL;
sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CT_AccessoriesServer* server = NULL;
// Create the CTestServer derived server
TRAPD(err, server = CT_AccessoriesServer::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
sched->Start();
}
delete server;
delete sched;
}
LOCAL_C void MainL()
{
// Leave the hooks in for platform security
#if (defined __DATA_CAGING__)
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().SecureApi(RProcess::ESecureApiOn);
#endif
CActiveScheduler* sched = NULL;
CleanupStack::PushL(sched);
sched=new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTlsOOMServer* server = NULL;
TRAPD(err,server = CTlsOOMServer::NewL());
CleanupStack::PushL(server);
if(!err)
{
RProcess::Rendezvous(KErrNone);
sched->Start();
}
CleanupStack::PopAndDestroy(2, sched); // server
}
// Secure variants much simpler
// For EKA2, just an E32Main and a MainL()
LOCAL_C void MainL()
/**
* Secure variant
* Much simpler, uses the new Rendezvous() call to sync with the client
*/
{
// Leave the hooks in for platform security
RProcess().DataCaging(RProcess::EDataCagingOn);
RProcess().DataCaging(RProcess::ESecureApiOn);
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CTestHtmlToCrtConverterSuite* server = NULL;
// Create the CTestServer derived server
TRAPD( err,server = CTestHtmlToCrtConverterSuite::NewL() );
if ( err == KErrNone )
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
sched->Start();
}
delete server;
delete sched;
}
void CMMFAudioPolicyServer::StartThreadL(TServerStart& aStart)
{
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CleanupStack::PushL(sched);
CActiveScheduler::Install(sched);
//Rename Audio Policy server name
RThread audioPolicyThread;
TName name;
name.Append(KMMFAudioPolicyServerName);
//We are ignoring the error code returned from User::RenameThread
//as it is not important here, may be for profiling
User::RenameThread(name);
CMMFAudioPolicyServer* server = CMMFAudioPolicyServer::NewL();
CleanupStack::PushL(server);
aStart.iPolicyServerHandle = server->Server();
// Sync with the client and enter the active scheduler
RThread::Rendezvous(KErrNone);
sched->Start();
CleanupStack::PopAndDestroy(2, sched); // sched, server
}
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
CActiveScheduler::Install(scheduler);
CTrapCleanup* cleanup = CTrapCleanup::New();
if (!cleanup)
{
return KErrNoMemory;
}
User::SetJustInTime(EFalse);
CTLbsGpsLocManager* agpsManager = 0;
TRAPD(err, agpsManager = CTLbsGpsLocManager::NewL());
if(!err)
{
// Sync with the client and enter the active scheduler
RProcess::Rendezvous(KErrNone);
scheduler->Start();
}
User::SetJustInTime(ETrue);
if (KErrNone == err)
{
delete agpsManager;
}
delete cleanup;
delete scheduler;
__UHEAP_MARKEND;
return err;
}
void CTestMMFHwDeviceObserver::StopActiveScheduler()
{
CActiveScheduler* activeScheduler;
activeScheduler = CActiveScheduler::Current();
activeScheduler->Stop();
}
EXPORT_C TInt TRPSOwnNumbers::RetrieveOwnNumbersL(RMobilePhone& aPhone)
{
RDEBUGPRINTLOGGER1(_L("RPS: TRPSOwnNumbers::RetrieveOwnNumbersL"));
RMobileONStore ownNumberStore;
User::LeaveIfError(ownNumberStore.Open(aPhone));
CleanupClosePushL(ownNumberStore);
// Get Own Number Information
RMobileONStore::TMobileONStoreInfoV1 ownNumberInfo;
RMobileONStore::TMobileONStoreInfoV1Pckg ownNumberInfoPckg(ownNumberInfo);
TRequestStatus status;
ownNumberStore.GetInfo(status, ownNumberInfoPckg);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
//
// Read entire Own Number store entries if supported
//
TInt errorReadingWhole = KErrNone;
TInt errorsExtractANumber(0);
if(ownNumberInfo.iCaps & (TUint32)RMobilePhoneStore::KCapsWholeStore)
{
// Reads phone's entire ON list
CMobilePhoneONList* onList = NULL;
// Assumes we have a scheduler to work with.
CActiveScheduler* sched = CActiveScheduler::Current();
CActiveONRetrieverRps* retriever = new(ELeave)CActiveONRetrieverRps(ownNumberStore, onList, errorReadingWhole, sched);
CleanupStack::PushL(retriever);
retriever->StartL();
sched->Start();
if(!errorReadingWhole)
{
// Verify that the name and number are OK.
TInt numOfEntry = onList->Enumerate();
for(TInt x = 0; x < numOfEntry; ++x)
{
if(ExtractANumber(onList->GetEntryL(x)) != KErrNone)
++errorsExtractANumber;
}
}
delete onList;
CleanupStack::PopAndDestroy();
}
TInt lenVoiceNum(iOwnVoiceNumber.Length());
TInt lenFaxNum(iOwnFaxNumber.Length());
TInt lenDataNum(iOwnDataNumber.Length());
if(!(lenVoiceNum && lenFaxNum && lenDataNum))
{
// Try reading ON store one entry at a time
for (TInt i = 1; i <= ownNumberInfo.iTotalEntries; i++)
{
RMobileONStore::TMobileONEntryV1 ownNumberEntry;
ownNumberEntry.iIndex = i;
RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(ownNumberEntry);
ownNumberStore.Read(status, ownNumberEntryPckg);
User::WaitForRequest(status);
ExtractANumber(ownNumberEntry);
}
// As the last resort,
// if the voice number has not been found, assume it is under the Unspecified service tag
if(iOwnVoiceNumber.Length() == 0)
{
RMobileONStore::TMobileONEntryV1 ownNumberEntry;
ownNumberEntry.iIndex = 1;
RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(ownNumberEntry);
ownNumberStore.Read(status, ownNumberEntryPckg);
User::WaitForRequest(status);
if (ownNumberEntry.iService == RMobilePhone::EServiceUnspecified)
{
TBuf<1> prependstr;
prependstr.Zero();
if(ownNumberEntry.iNumber.iTypeOfNumber == RMobilePhone::EInternationalNumber ||
ownNumberEntry.iNumber.iTelNumber.Left(2) == KUKCountryCode)
{
prependstr = KPlus;
}
iOwnVoiceNumber = prependstr;
iOwnVoiceNumber += ownNumberEntry.iNumber.iTelNumber;
}
}
}
CleanupStack::PopAndDestroy(); //ownNumberStore
//often fax and data numbers are blank on the SIM so if that is the case then set them to be same as voice
//Hopefully attempting to dial a data/fax call using the voice number should still work
if(iOwnDataNumber.Length() == 0)
iOwnDataNumber = iOwnVoiceNumber;
if(iOwnFaxNumber.Length() == 0)
iOwnFaxNumber = iOwnVoiceNumber;
RDEBUGPRINTLOGGER2(_L("RPS: iOwnVoiceNumber=%S"), &iOwnVoiceNumber);
RDEBUGPRINTLOGGER2(_L("RPS: iOwnDataNumber=%S"), &iOwnDataNumber);
RDEBUGPRINTLOGGER2(_L("RPS: iOwnFaxNumber=%S"), &iOwnFaxNumber);
return KErrNone;
}
TVerdict CTPKCS7ValidTest::doTestStepL()
{
if (TestStepResult() != EPass)
{
return TestStepResult();
}
__UHEAP_MARK;
TBool expectedValid;
if (GetBoolFromConfig(ConfigSection(),_L("IsValid"), expectedValid) == EFalse)
{
expectedValid = ETrue;
}
TInt err;
CPKCS7ContentInfo * contentInfo = NULL;
TRAP (err, contentInfo = CPKCS7ContentInfo::NewL(iRawData->Des()));
if(err == KErrNone)
{
CPKCS7SignedObject * p7 = NULL;
if( contentInfo->ContentType() == KPkcs7SignedData)
{
TRAP (err, p7 = CPKCS7SignedObject::NewL(*contentInfo));
//expired, and the case where certificate chain root is not on the device
if (!expectedValid)
{
if (err != KErrNone)
{
SetTestStepResult(EPass);
INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);
return TestStepResult();
}
}
if (err != KErrNone)
{
SetTestStepResult(EFail);
INFO_PRINTF2(_L("Got %d building PKCS7 object"), err);
}
else
{
CleanupStack::PushL (p7);
const RPointerArray<CPKCS7SignerInfo>& signers = p7->SignerInfo();
TBool isValid = EFalse;
HBufC8* certificateEncoding = NULL;
if(!p7->ValidateSignerL(*signers[0], certificateEncoding))
{
INFO_PRINTF1(_L("Couldn't validate signer"));
}
else
{
CActiveScheduler* sched = NULL;
if (CActiveScheduler::Current() == NULL)
{
INFO_PRINTF1(_L("Installing scheduler"));
sched = new (ELeave) CActiveScheduler();
CleanupStack::PushL (sched);
__UHEAP_MARK;
CActiveScheduler::Install (sched);
}
RPointerArray<CX509Certificate> roots (&iRootCertificate, 1);
CPKIXCertChain * chain = CPKIXCertChain::NewLC(iFs, *certificateEncoding, roots);
TTime tm;
_LIT(KDateCorrect1,"20040801:");
TBuf <24> theDate(KDateCorrect1);
TInt err=tm.Set(theDate);
if(err)
{
tm.HomeTime();
}
CPKIXValidationResult* result = CPKIXValidationResult::NewLC();
CTPKCS7Validator* validator = new (ELeave) CTPKCS7Validator (chain, result, &tm);
CleanupStack::PushL (validator);
validator->doValidate ();
sched->Start ();
if (result->Error().iReason == EValidatedOK)
{
isValid = ETrue;
INFO_PRINTF1(_L("Validation success"));
}
else
{
INFO_PRINTF2(_L("Validation failed: %d"), result->Error().iReason);
}
CleanupStack::PopAndDestroy(validator);
CleanupStack::PopAndDestroy(result);
CleanupStack::PopAndDestroy(chain);
if (sched)
{
CActiveScheduler::Install (NULL);
CleanupStack::PopAndDestroy (sched);
}
}
if (certificateEncoding)
{
CleanupStack::PopAndDestroy(certificateEncoding);
}
CleanupStack::PopAndDestroy (p7);
if (isValid != expectedValid)
{
SetTestStepResult(EFail);
if (expectedValid)
{
INFO_PRINTF1(_L("Expected valid, got invalid"));
}
else
{
INFO_PRINTF1(_L("Expected invalid, got valid"));
}
}
}
}
}
else
{
SetTestStepResult(EFail);
}
__UHEAP_MARKEND;
return TestStepResult();
}
TInt E32Main()
{
TInt err;
Test.Start(_L("Comm Driver Tests"));
CommStart();
Test.Printf(_L("Insert plug in then press a key\r\n"));
Test.Getch();
TEST(CTrapCleanup::New()!=NULL);
CActiveScheduler* Scheduler = new CActiveScheduler;
TEST(Scheduler!=NULL);
CActiveScheduler::Install(Scheduler);
/*
CTestSignals* testsignals = NULL;
TRAP(err, testsignals = CTestSignals::NewL(0));
TEST(err==KErrNone);
testsignals->Start();
Scheduler->Start();
delete testsignals;
CTestRandTerm* testrandterm = NULL;
TRAP(err, testrandterm = CTestRandTerm::NewL(0));
TEST(err==KErrNone);
testrandterm->Start();
Scheduler->Start();
delete testrandterm;
CTestPerf* testperf = NULL;
TRAP(err, testperf = CTestPerf::NewL(0));
TEST(err==KErrNone);
testperf->Start();
Scheduler->Start();
delete testperf;
*/
CTestXonXoff* testx = NULL;
TRAP(err, testx = CTestXonXoff::NewL(0));
TEST(err==KErrNone);
testx->Start();
Scheduler->Start();
delete testx;
/*
CTestXonXoff* testx1 = NULL;
TRAP(err, testx1 = CTestXonXoff::NewL(0));
TEST(err==KErrNone);
testx1->Start();
CTestXonXoff* testx2 = NULL;
TRAP(err, testx2 = CTestXonXoff::NewL(1));
TEST(err==KErrNone);
testx2->Start();
Scheduler->Start();
delete testx1;
delete testx2;
*/
Test.End();
return KErrNone;
}
LOCAL_C void LaunchClientProcessL()
{
__UHEAP_MARK;
RProcess::Rendezvous(KErrNone);
RSemaphore sem;
User::LeaveIfError(sem.OpenGlobal(KEglStressTest));
CleanupClosePushL(sem);
//Access data passed from the main process
TStressProcessInfo info;
TPckg<TStressProcessInfo> pckgInfo(info);
User::LeaveIfError(User::GetDesParameter(KMultiProcessSlot, pckgInfo));
//Create RSgDriver and open the image
RSgDriver driver;
User::LeaveIfError(driver.Open());
CleanupClosePushL(driver);
RSgImage image;
User::LeaveIfError(image.Open(info.iSgId));
CleanupClosePushL(image);
EGLDisplay display;
EGL_LEAVE_NULL(display, eglGetDisplay(EGL_DEFAULT_DISPLAY));
EGL_LEAVE_ERROR(eglInitialize(display, NULL, NULL));
EGL_LEAVE_ERROR(eglBindAPI(EGL_OPENVG_API));
//Initialise to remove arm compiler warnings
EGLConfig config = 0;
EGLContext context = EGL_NO_CONTEXT;
EGLSurface surface = EGL_NO_SURFACE;
if(info.iTestType == EStressRead)
{
TSgImageInfo sginfo;
User::LeaveIfError(image.GetInfo(sginfo));
//Create an independant pixmap surface on which to copy the vgimage
RSgImage image2;
User::LeaveIfError(image2.Create(sginfo, NULL, NULL));
CleanupClosePushL(image2);
ChooseConfigAndCreateContextL(display, context, config, image2, KStressTestChildAppPanic, info.iAlphaPre);
EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(display, config, image2, info.iAlphaPre));
CleanupStack::PopAndDestroy(&image2);
}
else
{
ChooseConfigAndCreateContextL(display, context, config, image, KStressTestChildAppPanic, info.iAlphaPre);
EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(display, config, image, info.iAlphaPre));
}
EGL_LEAVE_ERROR(eglMakeCurrent(display, surface, surface, context));
VGImage vgImage;
GenerateVgImageL(display, &image, vgImage);
/* Create and install the active scheduler */
CActiveScheduler* sched = new(ELeave) CActiveScheduler;
CActiveScheduler::Install(sched);
CleanupStack::PushL(sched);
TInt width = vgGetParameteri(vgImage, VG_IMAGE_WIDTH);
VgLeaveIfErrorL();
TInt height = vgGetParameteri(vgImage, VG_IMAGE_HEIGHT);
VgLeaveIfErrorL();
VGImageFormat format = static_cast<VGImageFormat>(vgGetParameteri(vgImage, VG_IMAGE_FORMAT));
VgLeaveIfErrorL();
TBool testPass = ETrue;
CTReadWriteChild* painter = CTReadWriteChild::NewL(vgImage, width, height, info.iByteSize, format, info.iTestType, testPass);
CleanupStack::PushL(painter);
painter->After(TTimeIntervalMicroSeconds32(0));
//Data access is synchronised from the main process
sem.Wait();
sched->Start();
if(testPass == EFalse)
{
// Leave with a 'known' test error so that we can catch this particular failure
User::Leave(KTestStressUnexpectedPixelError);
}
CleanupStack::PopAndDestroy(5, &sem); //painter, sched, image, driver, sem
__UHEAP_MARKEND;
}
