// Copyright (c) 2005-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:

 // SWIS test step implementation

 // 

 //

 /**

  @file

 */

 #include "installStep.h"

 #include "common.h"

 #include "tui.h"

 #include <e32std.h>

 #include <test/testexecutelog.h>

 #include <swi/launcher.h>

 #include <bautils.h>

 #include "swi/sisregistrysession.h"

 #include "swi/sisregistrypackage.h"

 #include "swi/sisregistryentry.h"

 #include "cleanuputils.h"

 using namespace Swi;

 //

 // CinstallStep

 //

 CinstallStep::~CinstallStep()

     {

     delete iUi;

     }

 CinstallStep::CinstallStep(TInstallType aInstallType, TBool aDoCancelTest)

     : iInstallType(aInstallType), iDoCancelTest(aDoCancelTest),

 	  iInstallSuccess(EFalse)

     {

     // Call base class method to set up the human readable name for logging

     switch (aInstallType)

         {

         case EUseFileHandle:

             SetTestStepName(KInstallFHStep);

             break;

         case EUseMemory:

             SetTestStepName(KInstallMemStep);

             break;

         case EUseFileName:

             SetTestStepName(KInstallStep);

             break;

         case EUseCAF:

             SetTestStepName(KInstallCAFStep);

             break;

         case EUseOpenFileName:

             SetTestStepName(KInstallOpenFileStep);

             break;

         case ECheckExitValue:

             SetTestStepName(KCheckedInstallStep);

             break;     

         }

     }

 /**

  * Override of base class virtual. Prepares for the test run of SWIS

  * @return TVerdict code

  */

 TVerdict CinstallStep::doTestStepPreambleL()

     {

     SetTestStepResult(EPass);

     // get step parameters

     TPtrC str;

     if (!GetStringFromConfig(ConfigSection(), _L("sis"), str))

         {

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF1(_L("FAIL: Missing SIS file name"));

         INFO_PRINTF1(HTML_RED_OFF);

         SetTestStepResult(EFail);

         return TestStepResult();

         }

     iSisFileName.Copy(str);

     INFO_PRINTF2(_L("Installing '%S'"), &iSisFileName);

     // create UI handler and populate the answers from XML file

     iUi = new(ELeave) TUI();

 	return TestStepResult();

     }

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters fom an ini file section

  * @return TVerdict code

  */

 TVerdict CinstallStep::doTestStepL()

     {

     INFO_PRINTF1(KInstallStep);

     // Try to set up a repository object, we'll need this if any

     // NotifyRequests are listed. Only open the repository if there are

     // notifys.

  	TInt bRet;

     // First find out if the install step is supposed to be successful.

     TInt insterr=KErrNone;

     bRet = GetIntFromConfig(ConfigSection(), KExpectedError, insterr );

     if(bRet!=1) insterr=KErrNone;

     CInstallPrefs* prefs = CInstallPrefs::NewLC();

     TInt err = DoInstallL(*prefs);        

 	iInstallSuccess = (err == KErrNone);

     // Expected error?

     if(insterr != err)

         {

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF3( _L("Installation return wrong error code, expected %d, got %d."), insterr, err );

         INFO_PRINTF1(HTML_RED_OFF);

         SetTestStepResult(EFail);

         }

    else

         {

         INFO_PRINTF2( _L("Installation error code %d (expected)."), err );

         }

     CleanupStack::PopAndDestroy(prefs);

     return TestStepResult();

     }

 TInt CinstallStep::DoInstallL(CInstallPrefs& aInstallPrefs)

     {

     TInt err=KErrNone;

     RFs fs;

     RFile file;

     switch (iInstallType)

         {

         case EUseFileName:

             err = Launcher::Install(*iUi, iSisFileName, aInstallPrefs);

             INFO_PRINTF2(_L("EUseFileName: Install return code was %d"), err);

             return err;

         case EUseOpenFileName:

         // open the file as a shared for readers only

             {

             User::LeaveIfError(fs.Connect());

             fs.ShareProtected();

             CleanupClosePushL(fs);

             RFile file;

             User::LeaveIfError(file.Open(fs, iSisFileName, EFileShareReadersOnly));

             CleanupClosePushL(file);

             TInt error = Launcher::Install(*iUi, iSisFileName, aInstallPrefs);

             CleanupStack::PopAndDestroy(2, &fs);

             return error;            

             }

         case EUseFileHandle:

             {

             RFs fs;

             User::LeaveIfError(fs.Connect());

             fs.ShareProtected();

             CleanupClosePushL(fs);

             RFile file;

             User::LeaveIfError(file.Open(fs, iSisFileName, 0));

             CleanupClosePushL(file);

             TInt error=Launcher::Install(*iUi, file, aInstallPrefs);

             CleanupStack::PopAndDestroy(2, &fs);

             return error;

             }

         case ECheckExitValue:

             {

             // This test case does an install and checks for pass or failure

             // TInt err = Launcher::Install(*iUi, iSisFileName, *prefs);

             TInt err = Launcher::Install(*iUi, iSisFileName, aInstallPrefs);

             INFO_PRINTF2(_L("Install return code was %d"), err);

             TPtrC expected;

             if (!GetStringFromConfig(ConfigSection(), _L("result"), expected))

                 {

                 return ETestSuiteError;

                 }

             else 

                 {

                 _LIT(KSucess, "sucess");

                 _LIT(KFailure, "failure");

                 TVerdict result;

                 if (expected.CompareF(KSucess) == 0)

                     {

                     result = (err == KErrNone ? EPass : EFail);

                     }

                 else if (expected.CompareF(KFailure) == 0)

                     {

                     result = (err != KErrNone ? EPass : EFail);

                     }

                 else 

                     {

                     result = ETestSuiteError;

                     }

                 return result;

                 }

             }

             // Unreachable.

 //          break;    

         }

     // Shouldn't get here

     return KErrGeneral;

     }

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CinstallStep::doTestStepPostambleL()

     {

     CheckFilesExistL();

     CheckFilesNonExistL();

     return TestStepResult();

     }

 /** Need to wait a few seconds for ECOM to

 discover the change. Otherwise the next step may fail.

 @pre caller has checked the install/uninstall

 is successful. Otherwise will waste 30 s.

 */

 void Cinstallers::WaitForEComReDiscoveryL()

 	{

     REComSession& ecomSession = REComSession::OpenL();

 	CleanupClosePushL(ecomSession);

 	TRequestStatus ecomstatus;

 	ecomSession.NotifyOnChange(ecomstatus);

 	RTimer timer;

 	User::LeaveIfError(timer.CreateLocal());

 	CleanupClosePushL(timer);

 	const TInt KInterval = 30000000; // 30 s

 	TRequestStatus timerstatus;

 	timer.After(timerstatus, KInterval);

 	User::WaitForRequest(ecomstatus, timerstatus);

 	if (ecomstatus == KRequestPending)

 		{

 		ecomSession.CancelNotifyOnChange(ecomstatus);

 		User::WaitForRequest(ecomstatus);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF1(_L("No notification from ECOM"));

         INFO_PRINTF1(HTML_RED_OFF);

 		// does not affect test result as this is the equivalent of

 		// DELAY 30000 in the script.

 		}

 	else

 		{

 		timer.Cancel();

 		User::WaitForRequest(timerstatus);

         INFO_PRINTF1(_L("ECOM has discovered the change"));

 		}

 	CleanupStack::PopAndDestroy(2); // ecomsession, RTimer

 	REComSession::FinalClose();

 	}

 /** Resolver installation step */

 /** constructor */

 CResolverInstallStep::CResolverInstallStep(CinstallStep::TInstallType aInstallType)

 	: CinstallStep(aInstallType)

 	{

 	}

 /** destructor */

 CResolverInstallStep::~CResolverInstallStep()

 	{

 	iLibrary.Close();

 	}

 /** uses CinstallStep::dotestStepL to do the install.

 But adds an optional step of loading a DLL before, and

 a step to wait for ECom rediscovery after.

 */

 TVerdict CResolverInstallStep::doTestStepL()

 	{

 	TPtrC libraryPath;

     if (GetStringFromConfig(ConfigSection(), _L("loadresolver"), libraryPath))

 		{

 		TUidType nullUid;

 		TInt err = iLibrary.Load(libraryPath, nullUid);

         if (err != KErrNone)

 	        {

 	        ERR_PRINTF2(_L("Preload resolver failed %d"), err);

 	        return EFail;

 	        }

 		}

 	// continue to do the actual install.

 	TVerdict ret = CinstallStep::doTestStepL();

 	if (iInstallSuccess)

 		{

 		WaitForEComReDiscoveryL();

 		}

 	return ret;

 	}

 /* *******************************************************************************

  *  Code below was copies from

  *       \master\common\generic\security\swi\test\tuiscriptadaptors\tswisstep.cpp

  *

  *  If there are any problems with this code, it may be worth contacting the

  *  Security team.

  * *******************************************************************************/

 //

 // CuninstallStep

 //

 CuninstallStep::~CuninstallStep()

     {

     delete iUi;

     }

 CuninstallStep::CuninstallStep(TUninstallType aType, TBool aDoCancelTest)

     : iType(aType), iDoCancelTest(aDoCancelTest)

     {

     // Call base class method to set up the human readable name for logging

     SetTestStepName(KUninstallStep);

     }

 /**

  * Override of base class virtual. Prepares for the test run of SWIS

  * @return TVerdict code

  */

 TVerdict CuninstallStep::doTestStepPreambleL()

     {

     // get step parameters

     TInt uid=0;

     TPtrC str;

     if (!GetHexFromConfig(ConfigSection(), _L("uid"), uid))

         {

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF1(_L("Missing uid"));

         INFO_PRINTF1(HTML_RED_OFF);

         SetTestStepResult(EFail);

         return TestStepResult();

         }

     iUid.iUid=uid;

     if (iType == EByPackage)

         {

         TPtrC vendorName;

         if (!GetStringFromConfig(ConfigSection(), _L("vendorName"), vendorName))

             {

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF1(_L("Missing Vendor Name"));

             INFO_PRINTF1(HTML_RED_OFF);

             SetTestStepResult(EFail);

             return TestStepResult();

             }

         iVendorName.Set(vendorName);

         TPtrC packageName;

         if (!GetStringFromConfig(ConfigSection(), _L("packageName"), packageName))

             {

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF1(_L("Missing Package Name"));

             INFO_PRINTF1(HTML_RED_OFF);

             SetTestStepResult(EFail);

             return TestStepResult();

             }

         iPackageName.Set(packageName);

         INFO_PRINTF4(_L("Uninstalling %D, %S, %S"), 

             iUid.iUid, &iPackageName, &iVendorName);

         // create UI handler and populate the answers from XML file

         iUi = new(ELeave) TUI;

         }

     else if (iType== EByUid)

         {

         INFO_PRINTF2(_L("Uninstalling '%D'"), iUid.iUid);

         // create UI handler and populate the answers from XML file

         iUi = new(ELeave) TUI;

         }

     return TestStepResult();

     }

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters fom an ini file section

  * @return TVerdict code

  */

 TInt CuninstallStep::DoUninstallL()

     {

     TInt err=0;

     INFO_PRINTF1(KUninstallStep);

     if (iType == EByUid)

         {

         // launch the installation

         err = Launcher::Uninstall(*iUi, iUid); 

         return err; 

         }

     else if (iType == EByPackage)

         {

         err = 0;

         // Go through list of packages from base package to get augmentations.

         CSisRegistryPackage* uninstallPackage=CSisRegistryPackage::NewLC(iUid, iPackageName, iVendorName);

         INFO_PRINTF3(_L("UnInstalling '%S', '%S'"), &iPackageName, &iVendorName);

         // err=Launcher::Uninstall(*iUi, *uninstallPackage);

 		RSisRegistrySession registrySession;

         User::LeaveIfError(registrySession.Connect());

         CleanupClosePushL(registrySession);

         RSisRegistryEntry registryEntry;

         User::LeaveIfError(registryEntry.Open(registrySession, iUid));

         CleanupClosePushL(registryEntry);

         CSisRegistryPackage* package=registryEntry.PackageL();

         CleanupStack::PushL(package);

         if (*package == *uninstallPackage)

             {

             err=Launcher::Uninstall(*iUi, *package); 

             }

         else

             {

             // check augmenations

             RPointerArray<CSisRegistryPackage> augmentationPackages;

 	        CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(augmentationPackages);

             registryEntry.AugmentationsL(augmentationPackages);

             for (TInt i=0; i < augmentationPackages.Count(); ++i)

                 {

                 if (*augmentationPackages[i] == *uninstallPackage)

                     {

                     err=User::LeaveIfError(Launcher::Uninstall(*iUi, *augmentationPackages[i])); 

                     break;

                     }

                 }

             if (err != 0)

 	        	{

 	        	INFO_PRINTF1(HTML_RED);

 	            ERR_PRINTF2(_L("Package Augmentation Not found for '%s' "), &iPackageName);

 	            INFO_PRINTF1(HTML_RED_OFF);

 	            SetTestStepResult(EFail);

 	            return TestStepResult();

 	        	}

             CleanupStack::PopAndDestroy(&augmentationPackages);

             }    

         CleanupStack::PopAndDestroy(3, &registrySession);

         CleanupStack::PopAndDestroy(uninstallPackage);

         }

     return err;

     }

 /* ******************************************************************************

  *  End of copied code.

  * ******************************************************************************/

 TVerdict CuninstallStep::doTestStepL()

     {

     INFO_PRINTF1(KUninstallStep);

     // Wait a fraction over a second. This is necessary because we may just

     // have been messing about with repository settings and if the install

     // happens really quickly we might not see a datestamp change (esp. on

     // hardware where the timestamp granularity is poor).

     User::After(1100000);

     User::LeaveIfError(DoUninstallL());

     return TestStepResult();

     }

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CuninstallStep::doTestStepPostambleL()

     {

     CheckFilesExistL();

     CheckFilesNonExistL();

     return TestStepResult();

     }

 // CResolverUninstallStep class

 /** constructor */

 CResolverUninstallStep::CResolverUninstallStep(CuninstallStep::TUninstallType aType)

 	: CuninstallStep(aType)

 	{

 	}

 /** nothing to do in destructor */

 CResolverUninstallStep::~CResolverUninstallStep()

 	{

 	}

 /** runs CuninstallStep::doTestStepL and then

 do a WaitForEComReDiscoveryL */

 TVerdict CResolverUninstallStep::doTestStepL()

 	{

 	TVerdict ret = CuninstallStep::doTestStepL();

 	if (ret == EPass)

 		{

 		WaitForEComReDiscoveryL();

 		}

     return ret;

 	}

 Cinstallers::~Cinstallers()

 /**

  * Destructor

  */

     {

     }

 Cinstallers::Cinstallers()

 /**

  * Constructor

  */

     {

     }

 void Cinstallers::CheckFilesL(const TDesC& aNumEntries,

                                    const TDesC& aEntryBase, TBool aCheckExist)

     {

     TInt numEntries=0;

     TInt nErr=0;

     _LIT(Report_CheckFiles, "CheckFilesL");

     INFO_PRINTF1(Report_CheckFiles);

     RFs fs;

     User::LeaveIfError(fs.Connect());

     fs.ShareProtected();

     CleanupClosePushL(fs);

     if (GetIntFromConfig(ConfigSection(), aNumEntries, numEntries) && numEntries!=0)

         {

         INFO_PRINTF1(Report_CheckFiles);

         TPtrC fname;

         for (TInt i=0; i<numEntries; i++)

             {

             // construct name of the key

             const TInt KKeyBufSize=64;

             TBuf<KKeyBufSize> keyBuf(aEntryBase);

             keyBuf.AppendNum(i);

             if (GetStringFromConfig(ConfigSection(), keyBuf, fname))

                 {            

                 TInt timeout=1e7;

                 TInt wait=2.5e5;

                 // check if the file (doesn't) exist. Give it some time if

                 // we see a failure in case there's a race with the

                 // (un)installer 

                 if (aCheckExist)

                     {

                     TInt sec=timeout;

                     while (!BaflUtils::FileExists(fs, fname) && (sec>0))

                         {

                         User::After(wait);

                         sec -= wait;

                         };

                     if (!BaflUtils::FileExists(fs, fname))

                         {

                         INFO_PRINTF1(HTML_RED);

                         ERR_PRINTF2(_L("File missing: %S"), &fname);

                         INFO_PRINTF1(HTML_RED_OFF);

                         nErr++;

                         }

                     }

                 else

                     {

                     TInt sec=timeout;

                     while (BaflUtils::FileExists(fs, fname) && (sec>0))

                         {

                         User::After(wait);

                         sec -= wait;

                         };

                     if (BaflUtils::FileExists(fs, fname))

                         {

                         INFO_PRINTF1(HTML_RED);

                         ERR_PRINTF2(_L("File exists (but shouldn't): %S"), &fname);

                         INFO_PRINTF1(HTML_RED_OFF);

                         nErr++;

                         }

                     }

                 }

             else

                 {

                 // the string must exist, otherwise the config is invalid

                 INFO_PRINTF1(HTML_RED);

                 ERR_PRINTF2(_L("Missing file name for key '%S'"), &keyBuf);

                 INFO_PRINTF1(HTML_RED_OFF);

                 nErr++;

                 }

             }

         }

         if (nErr)

             SetTestStepResult(EFail);

         CleanupStack::PopAndDestroy(1, &fs);

     }

 void Cinstallers::CheckFilesExistL()

     {

     _LIT(KNumExist, "numexist"); // this specifies how many files to check for

     _LIT(KExistBase, "exist");   // + number (0-based) = file to check for

     CheckFilesL(KNumExist, KExistBase, ETrue);

     }

 void Cinstallers::CheckFilesNonExistL()

     {

     _LIT(KNumNonExist, "numnonexist"); // this specifies how many files to check for

     _LIT(KNonExistBase, "nonexist"); // + number (0-based) = file to check for

     CheckFilesL(KNumNonExist, KNonExistBase, EFalse);

     }