// Copyright (c) 2004-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 <schinfo.h>

#include <schinfointernal.h>

#include <schtask.h>

#include <s32file.h>

#include <e32math.h>

#include <e32cons.h>

#include <e32test.h>

#include "platsectaskcommon.h"

// Constants

_LIT(KConsoleName, "PlatSecTaskHandler");

static void SignalTestExe()

	{

	_LIT(KSchSemaphoreName, "SCHMinimalTaskHandler");

	RSemaphore sem;

	TInt ret = sem.OpenGlobal(KSchSemaphoreName);

	if (ret == KErrNone)

		{

		sem.Signal();

		sem.Close();

		}

	}

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

LOCAL_C TInt GetRandomNumber(const TInt aLow, const TInt aHigh, TInt64& aSeed)

	{

	TReal initialRand = (Math::FRand(aSeed) * (aHigh - aLow));

	TInt32 rand;

	// Round to 0 decimal places, ie. the nearest whole numer

	Math::Round(initialRand, initialRand, 0);

	Math::Int(rand, initialRand);

	return (aLow + rand);

	}

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

LOCAL_C void DestroyArray(TAny* aArray)

	{

	static_cast<RArray<TCapability>*>(aArray)->Reset();

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1345

@SYMTestCaseDesc	    Platform security Task handler test 

@SYMTestPriority 	    High

@SYMTestActions  	    Attempt to test the contents of a task file.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/				

LOCAL_C void ConstructConsoleL(RFile& aTaskFile, RTest& aTest)

	{

	CConsoleBase* console=Console::NewL(KConsoleName, TSize(KConsFullScreen, KConsFullScreen));

	CleanupStack::PushL(console);

	console->Printf(_L(" contents of task file\n"));

	RArray<TCapability> enforcedCaps;

	CleanupStack::PushL(TCleanupItem(&DestroyArray,&enforcedCaps));

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

		{

		// we're checking here to see which capabilities are enforced, skipping

		// ECapabilityMultimediaDD and ECapabilityWriteDeviceData as it is

		// needed to write persistent schedules upon which this test relies.

		if (i == KPlatSecTestCapability)

			continue;

		else if (i == ECapabilityWriteDeviceData)

			continue;

		else if (PlatSec::IsCapabilityEnforced((TCapability)i))

			enforcedCaps.Append((TCapability)i);

		}

	TBool isTestCapabilityEnforced = PlatSec::IsCapabilityEnforced(KPlatSecTestCapability);

	CFileStore* store;

	store = CDirectFileStore::FromLC(aTaskFile);

	RStoreReadStream instream;

	instream.OpenLC(*store,store->Root());

	TInt count = instream.ReadInt32L();

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

		{

		CScheduledTask* task = CScheduledTask::NewLC(instream);

		aTest(task->Info().iName.CompareF(KPlatSecTaskName)==0);

		aTest(task->Data().CompareF(KPlatSecTaskData)==0);

		aTest(task->SecurityInfo().iSecureId==KPlatSecTestSid); //This is the SID of tschsvrplatsec

		// check that client has capability it should have

		if(isTestCapabilityEnforced)

			aTest(task->SecurityInfo().iCaps.HasCapability(KPlatSecTestCapability));

		// check that the client has ECapabilityWriteDeviceData

		aTest(task->SecurityInfo().iCaps.HasCapability(ECapabilityWriteDeviceData));

		// check that client doesn't have any other capabilities

		for (TInt j=enforcedCaps.Count()-1; j>=0; --j)

			{

			aTest(!task->SecurityInfo().iCaps.HasCapability(enforcedCaps[j]));

			}

		CleanupStack::PopAndDestroy(task);

		}

	console->Printf(_L("Pausing for a one second..."));

	User::After(1000000);

	CleanupStack::PopAndDestroy(4); // instream, store, enforcedCaps, console

	}

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

LOCAL_C TInt Execute()

	{

	TInt err = KErrNoMemory;

	CTrapCleanup* cleanup=CTrapCleanup::New();	//can fail

	if (cleanup)

		{

		_LIT(KPlatSecTestName, "PlatSectTaskHandlerTest");

		RTest theTest(KPlatSecTestName);

		theTest.Start(KPlatSecTestName);

		theTest.Title();

		RFile file;

		// Adopt the task file from the Task Scheduler

		err = file.AdoptFromCreator(TScheduledTaskFile::FsHandleIndex(),

									TScheduledTaskFile::FileHandleIndex());

		if (err != KErrNone)

			return err;

		// The aParam is the name of a file where the relevant CTaskExCmdLine is

		// do the executing 

		theTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1345 "));

		TRAPD(err, ConstructConsoleL(file, theTest));

		if(err == KErrNone)

			{

			// Sometimes we want to return a bogus error value, 

			// sometimes we don't.

			TTime now;

			now.HomeTime();

			TInt64 seed = now.Int64();

			err = GetRandomNumber(-50, 200, seed); //20% chance of error being returned

			}

		file.Close();// Close the file

		theTest.End();

		theTest.Close();

		delete cleanup;

		}

	SignalTestExe();		

	return err;

	}

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

GLDEF_C TInt E32Main()

	{

	return Execute();

	}