egl/egltest/endpointtestsuite/automated/src/localtestbase.cpp
changeset 136 62bb7c97884c
parent 98 bf7481649c98
equal deleted inserted replaced
121:d72fc2aace31 136:62bb7c97884c
    69         iResultLog->LogResult(iTestIdVerdict);
    69         iResultLog->LogResult(iTestIdVerdict);
    70         }
    70         }
    71     
    71     
    72     DoPostambleL();
    72     DoPostambleL();
    73     delete iResultLog;
    73     delete iResultLog;
       
    74     iResultLog = NULL;
    74     iResultOutQueue.Close();
    75     iResultOutQueue.Close();
    75     iParamsInQueue.Close();
    76     iParamsInQueue.Close();
    76     return EPass;
    77     return EPass;
    77     }
    78     }
    78 
    79 
   403     }
   404     }
   404 
   405 
   405 
   406 
   406 void CTestIdResultLogger::LogResult(TVerdict aVerdict)
   407 void CTestIdResultLogger::LogResult(TVerdict aVerdict)
   407     {
   408     {
   408     TBuf<20> verdict;
   409     const TInt KMaxVerdictLength = 20;
       
   410     TBuf<KMaxVerdictLength> verdict;
   409     switch(aVerdict)
   411     switch(aVerdict)
   410         {
   412         {
   411         case EPass:           verdict.Append(_L("PASS"));            break;
   413         case EPass:           verdict.Append(_L("PASS"));            break;
   412         case EFail:           verdict.Append(_L("FAIL"));            break;
   414         case EFail:           verdict.Append(_L("FAIL"));            break;
   413         case EInconclusive:   verdict.Append(_L("INCONCLUSIVE"));    break;
   415         case EInconclusive:   verdict.Append(_L("INCONCLUSIVE"));    break;
   430     }
   432     }
   431 
   433 
   432 
   434 
   433 TInt CTestIdResultLogger::PanicMonitorMain(TAny* aSelf)
   435 TInt CTestIdResultLogger::PanicMonitorMain(TAny* aSelf)
   434     {
   436     {
       
   437     CTestIdResultLogger* self = static_cast<CTestIdResultLogger*>(aSelf);
       
   438     
       
   439     //Create cleanup stack.
   435     CTrapCleanup* cleanup = CTrapCleanup::New();
   440     CTrapCleanup* cleanup = CTrapCleanup::New();
   436 
   441     ASSERT(cleanup);
   437     TRAPD(err,
   442     
   438         //Create active scheduler.
   443     //Create active scheduler.
   439         CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
   444     CActiveScheduler* scheduler = new CActiveScheduler();
   440         CleanupStack::PushL(scheduler);
   445     ASSERT(scheduler);
   441         CActiveScheduler::Install(scheduler);
   446     CActiveScheduler::Install(scheduler);
   442 
   447     
   443         //Run MainL.
   448     TRAPD(err,  self->PanicMonitorMainL());
   444         CTestIdResultLogger* self = static_cast<CTestIdResultLogger*>(aSelf);
       
   445         self->PanicMonitorMainL();
       
   446 
       
   447         //Clean up.
       
   448         CleanupStack::PopAndDestroy(scheduler);
       
   449         );
       
   450     
       
   451     __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
   449     __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
   452 
   450     
       
   451     delete scheduler;
   453     delete cleanup;
   452     delete cleanup;
   454     return KErrNone;
   453     return KErrNone;
   455     }
   454     }
   456     
   455     
   457 
   456 
   539   */
   538   */
   540 TInt E32Main()
   539 TInt E32Main()
   541 	{
   540 	{
   542 	__UHEAP_MARK;
   541 	__UHEAP_MARK;
   543 	CTrapCleanup* cleanup = CTrapCleanup::New();
   542 	CTrapCleanup* cleanup = CTrapCleanup::New();
   544 	if(cleanup == NULL)
   543 	if(!cleanup)
   545 		{
   544 		{
   546 		return KErrNoMemory;
   545 		return KErrNoMemory;
   547 		}
   546 		}
   548 	TRAPD(err,MainL());
   547 	TRAPD(err,MainL());
   549 
   548