diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/e32test/secure/t_shal.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/kernelhwsrv/kerneltest/e32test/secure/t_shal.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,271 @@
+// 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);
+    }
+