// 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 the License "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:
// Test the ability of the debug system to handle events from several debug targets
//
//

#include <e32base.h>
#include <e32property.h>

#include <hal.h>
#include <e32test.h>

#include "t_multi_target.h"
#include "t_target_launcher.h"
#include "t_rmdebug_app.h"

#ifdef KERNEL_OOM_TESTING
  #ifdef USER_OOM_TESTING
    #error "Cannot define both KERNEL_OOM_TESTING and USER_OOM_TESTING"
  #endif
#endif


using namespace Debug;

const TVersion securityServerVersion(0,1,1);

const TVersion testVersion(2,1,0);

#ifdef SYMBIAN_STANDARDDEBUG
LOCAL_D RTest test(_L("T_RMDEBUG_MULTI_TARGET"));
#endif

#ifdef SYMBIAN_OEMDEBUG
LOCAL_D RTest test(_L("T_RMDEBUG_MULTI_TARGET_OEM"));
#endif

#ifdef SYMBIAN_OEM2DEBUG
LOCAL_D RTest test(_L("T_RMDEBUG_MULTI_TARGET_OEM2"));
#endif



CMultiTargetAgent* CMultiTargetAgent::NewL()
//
// CMultiTargetAgent::NewL
//
  {
  CMultiTargetAgent* self = new(ELeave) CMultiTargetAgent();

  self->ConstructL();

  return self;
  }


CMultiTargetAgent::~CMultiTargetAgent()
//
// CMultiTargetAgent destructor
//
    {
    RDebug::Printf("~CMultiTargetAgent\n");
    iServSession.Close();
    }


CMultiTargetAgent::CMultiTargetAgent() : 
    iEventPtr( (TUint8*)&iEventInfo, sizeof(TEventInfo) )
    {
    }


void CMultiTargetAgent::ConstructL()
//
// CMultiTargetAgent::ConstructL
//
  {
  }

/**
 * Helper code for the stepping tests. Returns the number of nanokernel ticks in one second.
 *
 * @return Number of nanokernel ticks. 0 if unsuccesful.
 */
TInt CMultiTargetAgent::HelpTicksPerSecond(void)
  {
  TInt nanokernel_tick_period;
  HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

  ASSERT(nanokernel_tick_period != 0);

  static const TInt KOneMillion = 1000000;

  return KOneMillion/nanokernel_tick_period;
  }

void CMultiTargetAgent::ClientAppL()
//
// Performs each test in turn
//
  {
  TInt err = iServSession.Connect(securityServerVersion);
  if (err != KErrNone)
      {
      User::Panic(_L("Can't open server session"), err);
      }

  LaunchTargetsInOrderL();
  RDebug::Printf( "returning from CMultiTargetAgent::ClientAppL" );
  }

/**
  Launch a process

  @param aProcess The RProcess object to use to create the process
  @param aExeName File name of the executable to create the process from
  @param aCommandLine The command line to pass to the new process
  @return KErrNone on success, or one of the other system wide error codes
  */
TInt CMultiTargetAgent::LaunchProcess(RProcess& aProcess, TDesC & aExeName, TDesC & aCommandLine )
    {    
    TInt err = aProcess.Create( aExeName, aCommandLine );    
    if(err != KErrNone)
        {
        RDebug::Printf( "aProcess.Create ret %d", err);
        return err;
        }

    TRequestStatus status = KRequestPending;
    aProcess.Rendezvous(status);
    if(KRequestPending != status.Int())
        {
        // startup failed so kill the process
        aProcess.Kill(KErrNone);
        return status.Int();
        }
    else
        {
        // start up succeeded so resume the process
        aProcess.Resume();
        // Give the process a chance to run
        User::After( 500000 );
        return KErrNone;
        }
    }

void CMultiTargetAgent::SetupDebugServerL()
    {
    RDebug::Printf( "CMultiTargetAgent::SetupDebugServerL" );

    iTargets.ReserveL( KNumApps );

    RBuf targetName;
    CleanupClosePushL( targetName );

    for( TInt numApps = 0; numApps < KNumApps; numApps++ )
        {
        iTargets.AppendL( targetName );
        RDebug::Printf( "Attach to DSS for app %d ", numApps );

        iTargets[numApps].CreateL( KTargetExe().Length() + 2 );
        iTargets[numApps].Format( KTargetExe(), numApps+1 );

        TInt ret = iServSession.AttachExecutable( iTargets[numApps], EFalse );
        test( ret == KErrNone );

        RDebug::Printf( ">SetEventAction app %d,  EEventsStartThread EActionSuspend", numApps );
        ret = iServSession.SetEventAction( iTargets[numApps], EEventsStartThread, EActionSuspend );
        test( ret == KErrNone );

        RDebug::Printf( ">SetEventAction app %d,  EEventsAddProcess EActionContinue", numApps );
        ret = iServSession.SetEventAction( iTargets[numApps], EEventsAddProcess, EActionContinue );
        test( ret == KErrNone );

        RDebug::Printf( ">SetEventAction app %d,  EEventsRemoveProcess EActionContinue", numApps );
        ret = iServSession.SetEventAction( iTargets[numApps], EEventsRemoveProcess, EActionContinue );
        test( ret == KErrNone );
        }

    CleanupStack::PopAndDestroy( &targetName ); // targetName

    }



TInt CMultiTargetAgent::LaunchTargetsInOrderL()
    {
    RDebug::Printf( "CMultiTargetAgent::LaunchTargetsInOrderL" );
    
    RBuf launcher;
    CleanupClosePushL( launcher );
    launcher.CreateL( KLauncherExe() );
    
    RBuf launcherOptions;
    CleanupClosePushL( launcherOptions ); 
    launcherOptions.CreateL( KTargetOptions().Length() + 2 );
    launcherOptions.Format( KTargetOptions(), (TUint)ENormalExit );

    RDebug::Printf( ">LaunchProcess()" );
    RProcess launcherProc; 
    CleanupClosePushL( launcherProc );
    
    TInt ret = LaunchProcess( launcherProc, launcher, launcherOptions );
    RDebug::Printf( "<LaunchProcess() ret %d", ret );
    
    CleanupStack::PopAndDestroy( &launcherProc ); // launcherProc
    CleanupStack::PopAndDestroy( &launcherOptions ); // launcherOptions
    CleanupStack::PopAndDestroy( &launcher ); //launcher 

    test( ret == KErrNone );
    
    RSemaphore launchSemaphore;   
    CleanupClosePushL( launchSemaphore );
            
    TFindSemaphore launchSemFinder( KLaunchMutexNameSearchString );
    TFullName mutexResult;
    ret = launchSemFinder.Next(mutexResult);
    RDebug::Printf( ">  Find Launch Semaphote.Next ret=%d, %lS", ret, &mutexResult );
    test( ret == KErrNone );   
     
    ret = launchSemaphore.OpenGlobal( mutexResult );
    RDebug::Printf( "> OpenGlobal mutex ret=%d", ret );         
    test( ret == KErrNone );    
    
    TBool thisLaunchCompleted; 

    SetupDebugServerL();
   
    for( TInt numLaunches = KNumLaunches; numLaunches > 0; numLaunches-- )
        {
        for( TInt numApps = KNumApps; numApps > 0; numApps-- )
            {
            thisLaunchCompleted = EFalse;
            // This will trigger the launcher app to launch the next target
            RDebug::Printf( " >Mutex.Signal app=%d, launch=%d", numApps, numLaunches);
            launchSemaphore.Signal();
            
            RBuf8 tgt8Name; 
            CleanupClosePushL( tgt8Name );
           
            RBuf tgtCollapseName;
            CleanupClosePushL( tgtCollapseName );
                    
            tgtCollapseName.CreateL( iTargets[numApps-1] );
            tgt8Name.CreateL( tgtCollapseName.Collapse() );
            

            while( ! thisLaunchCompleted )
                {
                RDebug::Printf( ">GetEvent app %d for %S", numApps, &tgt8Name );
                iServSession.GetEvent( iTargets[numApps-1], iStatus, iEventPtr );
          
                // Wait for the target to get started.
                RDebug::Printf( " >Wait for event from target app=%d, launch=%d\n", numApps, numLaunches);
                User::WaitForRequest( iStatus );
                RDebug::Printf( " <Wait for request returned with status %d", iStatus.Int() );
                test( iStatus==KErrNone );
    
                RDebug::Printf( " > Got iEventType =%d, app=%d", iEventInfo.iEventType, numApps );
                switch( iEventInfo.iEventType )
                    {
                    case EEventsAddProcess:
                        {
                        RDebug::Printf( "Got EEventsAddProcess" );                        
                        TPtrC8 exeNamePtr8( iEventInfo.iAddProcessInfo.iFileName, iEventInfo.iAddProcessInfo.iFileNameLength );
                        
                        RBuf8 exeName8;
                        CleanupClosePushL( exeName8 );
                        exeName8.CreateL( exeNamePtr8 );
                        RDebug::Printf( " from event: exeName8=%S", &exeName8 );
                        CleanupStack::PopAndDestroy( &exeName8 );
                        
                        RBuf8 compareName8;
                        CleanupClosePushL( compareName8 );
                        compareName8.CreateL( KTargetExeName().Length() + 10 );
                        compareName8.Format( KTargetExeName(), numApps );
                        RDebug::Printf( " comparing to: compareName8=%S", &compareName8 );
                        
                        test( compareName8.CompareC( exeNamePtr8 ) == 0 );
                        CleanupStack::PopAndDestroy( &compareName8 );

                        RDebug::Printf( "Testing if event process id is valid" );
                        test( iEventInfo.iProcessIdValid );
                        RDebug::Printf( "Got iEventInfo.iProcessId=%d", I64LOW( iEventInfo.iProcessId ) );
                        
                        RProcess targetProc;
                        ret = targetProc.Open( TProcessId( iEventInfo.iProcessId ) );
                        RDebug::Printf( "RProcess open ret=%d",ret );
                        targetProc.Close();
                        test( ret == KErrNone );
                        
                        break;
                        }//EEventsAddProcess
                        
                    case EEventsStartThread:
                        {
                        RDebug::Printf( "Got EEventsStartThread" );
                         
                        TPtrC8 exeNamePtr8( iEventInfo.iStartThreadInfo.iFileName, iEventInfo.iStartThreadInfo.iFileNameLength );
                        RBuf8 exe8Name;
                        CleanupClosePushL( exe8Name );
                        exe8Name.CreateL( exeNamePtr8 );
                        RDebug::Printf( " from event: exeName8=%S", &exe8Name );
                        CleanupStack::PopAndDestroy( &exe8Name );
                        
                        test( tgt8Name.CompareC( exeNamePtr8 ) == 0 );
                        
                        RDebug::Printf( "Testing if event process id is valid" );
                        test( iEventInfo.iProcessIdValid );
                        RDebug::Printf( "Got iEventInfo.iProcessId=%d", I64LOW( iEventInfo.iProcessId ) );
                         
                        RDebug::Printf( "Testing if event thread id is valid" );
                        test( iEventInfo.iThreadIdValid );
                        RDebug::Printf( "Got iEventInfo.iThreadId=%d", I64LOW( iEventInfo.iThreadId ) );
                        
                        RThread targetThread;
                        CleanupClosePushL( targetThread );
                        
                        ret = targetThread.Open( TThreadId( iEventInfo.iThreadId ) );
                        RDebug::Printf( "RThread open ret=%d", ret );
                        test( ret == KErrNone ); 
                         
                        test( iEventInfo.iThreadId == targetThread.Id() );  

                        RDebug::Printf( "Resuming thread for app=%d, id=%d", numApps, I64LOW( targetThread.Id() ));
                        ret = iServSession.ResumeThread( iEventInfo.iThreadId );
                        CleanupStack::PopAndDestroy( &targetThread );
                        
                        test( ret == KErrNone );
                        
                        ret = iServSession.ResumeThread( iEventInfo.iThreadId );
                        break;                    
                        }//case EEventsStartThread                        

                    case ( EEventsRemoveProcess ):
                        {
                        RDebug::Printf( "*** Got EEventsRemoveProcess. app%d has exited. Moving on to next app", numApps );                        
                        thisLaunchCompleted = ETrue;
                        break;
                        }
                        
                    default :   
                        RDebug::Printf( "Got unknown event" );
                        test( EFalse );
                        break;
                    }
                }//while

            CleanupStack::PopAndDestroy( &tgtCollapseName ); // tgtCollapseName
            CleanupStack::PopAndDestroy( &tgt8Name ); // tgt8Name 
            }
        }    

        CleanupStack::PopAndDestroy( &launchSemaphore ); // launchSemaphore
      
        for( TInt i = iTargets.Count()-1; i>=0; i-- )
            {
            RDebug::Printf( "Closing target %d", i );
            iTargets[ i ].Close();
            }

        iTargets.Close();
        
        return KErrNone;
    }


GLDEF_C TInt E32Main()
    {
    TInt ret = KErrNone;
   
  
    CTrapCleanup* trap = CTrapCleanup::New();
    if (!trap)
      return KErrNoMemory;
    test.Title();
   
    CMultiTargetAgent *runModeAgent = CMultiTargetAgent::NewL();
    if (runModeAgent != NULL)
        {
        __UHEAP_MARK;
        TRAP(ret,runModeAgent->ClientAppL());
        __UHEAP_MARKEND;
        
        RDebug::Printf( "ClientAppL returned %d", ret );
        delete runModeAgent;
        }

    delete trap;
    return ret;
    }
