// 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();
	}