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

 // e32test\secure\t_shal.cpp

 // Overview:

 // Test the security aspects of the HAL class.

 // API Information:

 // HAL

 // Details:

 // - For a variety of capability sets, get and set HAL hardware attributes

 // and check that the results are as expected.

 // - Set and restore the XYInputCalibration.

 // - Add an event using UserSvr::AddEvent() and verify the resulting capability

 // status.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #define __INCLUDE_CAPABILITY_NAMES__

 #include <e32test.h>

 #include <e32hal.h>

 #include <hal.h>

 #include <e32svr.h>

 LOCAL_D RTest test(_L("T_SHAL"));

 TCapabilitySet Capabilities;

 TInt PolicingVerified = 0;

 LOCAL_C TBool Check(TInt aResult,TCapability aCap)

 	{

 	switch(aResult)

 		{

 	case KErrNotSupported:

 		RDebug::Print(_L("  Not Supported"));

 		return ETrue;

 	case KErrNone:

 		RDebug::Print(_L("  No Error"));

 		break;

 	case KErrPermissionDenied:

 		RDebug::Print(_L("  Permission Denied"));

 		break;

 	default:

 		RDebug::Print(_L("  Error %d"),aResult);

 		break;

 		}

 	if(Capabilities.HasCapability(aCap))

 		return aResult==KErrNone;

 	else if(PlatSec::IsCapabilityEnforced(aCap))

 		return aResult==KErrPermissionDenied;

 	else

 		return aResult==KErrNone;

 	}

 LOCAL_C void GetSetCheck(const char* aText,HALData::TAttribute aAttribute,TCapability aCap)

 	{

 	TBuf8<256> text=(const TUint8*)"HAL::Set(";

 	text.Append((const TUint8*)aText,User::StringLength((const TUint8*)aText));

 	text.Append(')'); 

 	test.Next(text.Expand());

 	TInt x = 0;

 	HAL::Get(aAttribute,x);

 	TInt r = HAL::Set(aAttribute,x);

 	test(Check(r,aCap));

 	}

 #define SET_CHECK(a,c) 	GetSetCheck(#a,a,c);

 LOCAL_C TInt DoTests()

 	{

 	TInt r;

 //	TInt x = 0;

 	//

 	// ECapabilityReadDeviceData

 	//

 #if 0

 	test.Start(_L("UserHal::MachineInfo()"));

     TMachineInfoV2Buf info;

 	r = UserHal::MachineInfo(info);

 	test(Check(r,ECapabilityReadDeviceData));

 #endif

 	//

 	// ECapabilityWriteDeviceData

 	//

 	SET_CHECK(HAL::EKeyboardClickState,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EKeyboardClickVolume,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EPenClickState,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EPenClickVolume,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ELanguageIndex,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EKeyboardIndex,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ESystemDrive,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ECaseSwitchDisplayOn,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ECaseSwitchDisplayOff,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EDisplayContrast,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EDisplayBrightness,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EBacklightState,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::EPenDisplayOn,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ELocaleLoaded,ECapabilityWriteDeviceData);

 	SET_CHECK(HAL::ECustomResourceDrive,ECapabilityWriteDeviceData);

 	test.Next(_L("UserHal::CalibrationPoints()"));

     TDigitizerCalibration xy;

 	UserHal::CalibrationPoints(xy);

 	r = UserHal::SetXYInputCalibration(xy);

 	test(Check(r,ECapabilityWriteDeviceData));

 	test.Next(_L("UserHal::RestoreXYInputCalibration()"));

 	UserHal::SaveXYInputCalibration();

 	r = UserHal::RestoreXYInputCalibration(ESaved);

 	test(Check(r,ECapabilityWriteDeviceData));

 	//

 	// ECapabilityMultimediaDD

 	//

 	SET_CHECK(HAL::EMouseState,ECapabilityMultimediaDD);

 	SET_CHECK(HAL::EMouseSpeed,ECapabilityMultimediaDD);

 	SET_CHECK(HAL::EMouseAcceleration,ECapabilityMultimediaDD);

 //	SET_CHECK(HAL::EDisplayMode,ECapabilityMultimediaDD);

 //	SET_CHECK(HAL::EDisplayPaletteEntry,ECapabilityMultimediaDD);

 	//

 	// ECapabilityPowerMgmt

 	//

 	SET_CHECK(HAL::EKeyboardBacklightState,ECapabilityPowerMgmt);

 	SET_CHECK(HAL::EAccessoryPower,ECapabilityPowerMgmt);

 	SET_CHECK(HAL::EDisplayState,ECapabilityPowerMgmt);

 	SET_CHECK(HAL::EKeyboardState,ECapabilityPowerMgmt);

 	SET_CHECK(HAL::EPenState,ECapabilityPowerMgmt);

 /*

 	test.Next(_L("UserHal::SwitchOff()"));

 	RTimer timer;

 	TRequestStatus done;

 	timer.CreateLocal();

 	TTime wakeup;

 	wakeup.HomeTime();

 	wakeup+=TTimeIntervalSeconds(4);

 	timer.At(done,wakeup);

 	r = UserHal::SwitchOff(); // May not actually turn off due to imminent RTimer.At()

 	test(Check(r,ECapabilityPowerMgmt));

 	User::WaitForRequest(done);

 */

 	//

 	// ECapabilitySwEvent

 	//

 	test.Next(_L("UserSvr::AddEvent()"));

 	TRawEvent event;

 	r = UserSvr::AddEvent(event);

 	test(Check(r,ECapabilitySwEvent));

 	//

 	test.End();

 	return 0x55555555;

 	}

 enum TTestProcessFunctions

 	{

 	ETestProcessDoTests,

 	};

 #include "testprocess.h"

 GLDEF_C TInt E32Main()

     {

 	Capabilities = TSecurityInfo(RProcess()).iCaps;

 	test.Title();

 	if(User::CommandLineLength())

 		{

 		TBuf<128> message;

 		__ASSERT_COMPILE(ECapability_Limit<64);

 		message.AppendFormat(_L("Tests with capabilities %08x%08x"),((TUint32*)&Capabilities)[1],((TUint32*)&Capabilities)[0]);

 		test.Start(message);

 		TInt result = DoTests();

 		// Don't test.End() so we don't get lots of 'Success's in logs

 		return(result);

 		}

 	test.Title();

 	test.Start(_L("Start"));

 	TInt c;

 	for(c=0; c<1+ECapability_Limit; c++)

 		{

 		RTestProcess p;

 		TRequestStatus s;

 		TBuf<128> message;

 		TCapabilitySet caps;

 		caps.SetAllSupported();

 		if(!caps.HasCapability((TCapability)c))

 			continue;

 		caps.RemoveCapability((TCapability)c);

 		TBuf8<128> capNameBuf;

 		capNameBuf.Copy((const TUint8*)CapabilityNames[c]);

 		TPtr capName(capNameBuf.Expand());

 		message.AppendFormat(_L("Tests with all capabilities except %S"),&capName);

 		test.Next(message);

 		p.Create(*(TUint32*)&caps,ETestProcessDoTests);

 		p.Logon(s);

 		p.Resume();

 		User::WaitForRequest(s);

 		test(p.ExitType()==EExitKill);

 		TInt result=s.Int()^0x55555555;

 		test(result==0);

 		CLOSE_AND_WAIT(p);

 		}

 	// Show results requiring manual inspection

 	_LIT(KSeperatorText,"----------------------------------------------------------------------------\n"); 

 	test.Printf(_L("\n"));

 	test.Printf(_L("RESULTS\n")); 

 	test.Printf(KSeperatorText);

 	TInt verified=1;

 	for(c=0; c<ECapability_Limit; c++)

 		if(!PlatSec::IsCapabilityEnforced((TCapability)c))

 			verified = 0;

 	if(!verified)

 		test.Printf(_L("*  Did NOT verify security checking\n"));

 	else

 		test.Printf(_L("*  Verified security checking\n"));

 	test.Printf(KSeperatorText);

 	// Wait for a while, or for a key press

 	test.Printf(_L("Waiting a short while for key press...\n"));

 	TRequestStatus keyStat;

 	test.Console()->Read(keyStat);

 	RTimer timer;

 	test(timer.CreateLocal()==KErrNone);

 	TRequestStatus timerStat;

 	timer.After(timerStat,20*1000000);

 	User::WaitForRequest(timerStat,keyStat);

 	TInt key = 0;

 	if(keyStat!=KRequestPending)

 		key = test.Console()->KeyCode();

 	timer.Cancel();

 	test.Console()->ReadCancel();

 	User::WaitForAnyRequest();

 	test.End();

 	return(0);

     }