/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

//  Include Files  

#include "stf.h"

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>			// Console

#include "executor.h"

#include "cmdparser.h"

#include "helper.h"

_LIT(KTextFailed, " failed, leave code = %d");

_LIT(KTextPressAnyKey, " [press any key to exit.]\n");

LOCAL_D CConsoleBase* console;

LOCAL_D TBool isPrompt = ETrue;

LOCAL_C TInt Execute()

    {

      //parse the command line

      CCmdParser* parser = NULL;    

      TRAPD(err, parser = CCmdParser::NewL());

      if (err != KErrNone)

          {

#ifdef _DEBUG

         RDebug::Print(_L("Command parser construction failed %d: "), err);

 #endif

         return err;

          }

      const TInt length = User().CommandLineLength();

      HBufC* cmdLine = NULL;

      TRAPD(err1 , cmdLine = HBufC::NewL(length));

      if (err1 != KErrNone)

           {

   #ifdef _DEBUG

           RDebug::Print(_L("Command line buffer construction failed %d: "), err1);

   #endif

           delete parser;

           return err1;

           }

      TPtr ptr = cmdLine->Des();

      User().CommandLine(ptr);

      ptr.TrimAll();

      TBool rst = parser->Parse(ptr);

      delete cmdLine;

      //end parse the command line.

      isPrompt = parser->IsPrompt();

      if (parser->IsHelp() || parser->IsVersion())

          {

          //only show help or version info.

          isPrompt = ETrue;

          CHelper* helper = NULL;

          TRAPD( err, helper = CHelper::NewL(console));

          if (err != KErrNone)

              {

  #ifdef _DEBUG

              RDebug::Print(_L("helper construction failed %d: "), err);

  #endif

              delete parser;

              return err;

              }

          if(parser->IsHelp())

              {

              helper->ShowHelp();            

              }

          else

              {

              helper->ShowVersion();

              }

          delete helper;

          }

      else

          {

          if (!rst)

              {

      #ifdef _DEBUG

              RDebug::Print(_L("arguments error."));

      #endif

              delete parser;

              return KErrArgument;

              } 

          // Construct the test client

           CExecutor* executor = NULL;

           TRAPD( err, executor = CExecutor::NewL(parser,console) );

           if (err != KErrNone)

               {

       #ifdef _DEBUG

               RDebug::Print(_L("STF executor construction failed %d: \n"), err);

       #endif

               delete parser;

               return err;

               }

               // Run tests

               TRAP( err, executor->RunTestsL() );

           if (err != KErrNone)

               {

               console->Printf(_L("STF execution failed with: %d \n"),err);

       #ifdef _DEBUG

               RDebug::Print(_L("RunTestsL left with %d: "), err);

       #endif

               }

           // Deallocate resources

           delete executor;

          }

      delete parser;

      return KErrNone;

    }

LOCAL_C void DoStartL()

    {

    // Create active scheduler (to run active objects)

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

    CleanupStack::PushL(scheduler);

    CActiveScheduler::Install(scheduler);

    TInt err = Execute();

    if(err != KErrNone)

        {

        console->Printf(_L("STF Get Error: %d."), err);

        if(err == KErrArgument)

                {

                console->Printf(_L("Arguments error.\n"));

                }

            else if(err == KErrNoMemory)

                {

                console->Printf(_L("No enough memory.\n"));    

                }

            else if(err == KErrNotFound)

                {

                console->Printf(_L("Required resouce not found.\n"));    

                }

            else if(err == KErrNotSupported)

                {

                console->Printf(_L("Operation not supported in this version.\n"));   

                }

            else

                {

                console->Printf(_L("Other unknow error.\n"));   

                }

        }

    // Delete active scheduler

    CleanupStack::PopAndDestroy(scheduler); 

    }

//  Global Variables

GLDEF_C TInt E32Main()

    {

    TInt processHandleCountBefore;

    TInt threadHandleCountBefore;

    RThread().HandleCount(processHandleCountBefore, threadHandleCountBefore);

    TInt reqsBefore = RThread().RequestCount();

    TInt processHandleCountAfter;

    TInt threadHandleCountAfter;

    TInt reqsAfter;

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TRAPD(createError, console = Console::NewL(_L("STF"), TSize(

               KConsFullScreen, KConsFullScreen)));

    if(createError)

        {

        return createError;

        }

    TRAPD(mainError, DoStartL());

    if(mainError)

        {

        console->Printf(KTextFailed, mainError);    

        }

    if(isPrompt)

        {

        console->Printf(KTextPressAnyKey);

        console->Getch();

        }

    reqsAfter = RThread().RequestCount();

    RThread().HandleCount(processHandleCountAfter, threadHandleCountAfter);

    if (reqsAfter != reqsBefore)

        {

#ifdef _DEBUG

        RDebug::Print(_L("Request count not matching! %d vs. %d: "),

        reqsBefore, reqsAfter);

#endif

        }

    if (threadHandleCountAfter != threadHandleCountBefore)

        {

#ifdef _DEBUG

        RDebug::Print(_L("Handle count not matching! %d vs. %d: "),

        threadHandleCountBefore, threadHandleCountAfter);

#endif

        }

    delete console;

    delete cleanup;

    __UHEAP_MARKEND;

    return KErrNone;

    }