// 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:
//

#include <e32kpan.h>
#include "t_property.h"

_LIT(KDefineName, "RProperty::Define() Basics");
 
CPropDefine::CPropDefine(TUid aCategory, TUint aKey, RProperty::TType aType) : 
	  CTestProgram(KDefineName), iCategory(aCategory), iKey(aKey), iType(aType)
	{
	}

void CPropDefine::Run(TUint aCount)
	{
	TUid mySid;
	mySid.iUid = RProcess().SecureId();

	for(TUint i = 0; i < aCount; ++i)
		{
		RProperty prop;

		//	Defines the attributes and access control for a property. This can only be done 
		//	once for each property. Subsequent attempts to define the same property will return
		//	KErrAlreadyExists.
		TInt r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrAlreadyExists);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);

		// Test defining properties in the default category (==our SID)
		r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrAlreadyExists);
		r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrAlreadyExists);
		r = prop.Delete(mySid, iKey);
		TF_ERROR(r, r == KErrNone);

		// Test re-definition doesn't change security settings
		// Defect DEF050961 - Re-defining an RProperty causes the security policy to be overwritten
		{
		TInt expectedResult = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)?KErrPermissionDenied:KErrNone;
		_LIT(KTestBytes,"abcd");
		r = prop.Define(iCategory, iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Attach(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		if (iType == RProperty::EInt)
			r = prop.Set(1);
		else
			r = prop.Set(KTestBytes);
		TF_ERROR(r, r == expectedResult);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrAlreadyExists);
		if (iType == RProperty::EInt)
			r = prop.Set(1);
		else
			r = prop.Set(KTestBytes);
		TF_ERROR(r, r == expectedResult);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		prop.Close();
		}

		// Define fails with KErrArgument if wrong type or attribute was specified.
		r = prop.Define(iCategory, iKey, RProperty::ETypeLimit, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrArgument);
		const TInt removed_KPersistent_attribute = 0x100;
		r  = prop.Define(iCategory, iKey, iType | removed_KPersistent_attribute, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrArgument);

		TSecurityPolicy badPolicy;
		*(TInt*)&badPolicy = -1;
		r = prop.Define(iCategory, iKey, iType, badPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrArgument);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, badPolicy);
		TF_ERROR(r, r == KErrArgument);

		if (iType == RProperty::EInt)
			{
			// Define fails with KErrArgument if aType is TInt and aPreallocate is not 0
			r = prop.Define(iCategory, iKey, RProperty::EInt, KPassPolicy, KPassPolicy, 16);
			TF_ERROR(r, r == KErrArgument);

			// Following defintion the property has a default value, 0 for integer properties
			r = prop.Define(iCategory, iKey, RProperty::EInt, KPassPolicy, KPassPolicy);
			TF_ERROR(r, r == KErrNone);
			TInt value;
			r = prop.Get(iCategory, iKey, value);
			TF_ERROR(r, r == KErrNone);
			TF_ERROR(value, value == 0);
			r = prop.Delete(iCategory, iKey);
			TF_ERROR(r, r == KErrNone);
			}
		else 
			{
			// Defne fails with KErrTooBig if aPeallocate is grater than KMaxPropertySize.
			r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy, RProperty::KMaxPropertySize);
			TF_ERROR(r, r == KErrNone);
			r = prop.Delete(iCategory, iKey);
			TF_ERROR(r, r == KErrNone);
			r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy, RProperty::KMaxPropertySize + 1);
			TF_ERROR(r, r == KErrTooBig);

			// Following defintion the property has a default value, zero-length data for byte-array and text 
			// properties. 
			r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy);
			TF_ERROR(r, r == KErrNone);
			TBuf<16> buf;
			r = prop.Get(iCategory, iKey, buf);
			TF_ERROR(r, r == KErrNone);
			TF_ERROR(buf.Size(), buf.Size() == 0);

			TBuf8<16> buf8;
			r = prop.Get(iCategory, iKey, buf8);
			TF_ERROR(r, r == KErrNone);
			TF_ERROR(buf8.Size(), buf8.Size() == 0);
			r = prop.Delete(iCategory, iKey);
			TF_ERROR(r, r == KErrNone);
			}

		// Pending subscriptions for this property will not be completed until a new value is published.
		r = prop.Attach(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		TRequestStatus status;
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNotFound);
		prop.Close();
		}
	}

_LIT(KDeleteName, "RProperty::Delete() Basics");
 
CPropDelete::CPropDelete(TUid aCategory, TUint aKey, RProperty::TType aType) : 
	  CTestProgram(KDeleteName), iCategory(aCategory), iKey(aKey), iType(aType)
	{
	}

void CPropDelete::Run(TUint aCount)
	{
	TUid mySid;
	mySid.iUid = RProcess().SecureId();
	for(TUint i = 0; i < aCount; ++i)
		{
		RProperty prop;

		// If the property has not been defined Delete fails with KErrNotFound.
		TInt r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNotFound);
	
		// Test deleting properties in the default category (==our SID)
		//deleting of property in the default category (==our SID) should fail until the property is defined
		r = prop.Delete(iKey);
		TF_ERROR(r, r == KErrNotFound);
		
		r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Delete(iKey);
		TF_ERROR(r, r == KErrNone);
				
		r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Delete(mySid, iKey);
		TF_ERROR(r, r == KErrNone);
		r = prop.Delete( iKey);
		TF_ERROR(r, r == KErrNotFound);
		
		r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Delete( iKey);
		TF_ERROR(r, r == KErrNone);
		r = prop.Delete(mySid, iKey);
		TF_ERROR(r, r == KErrNotFound);
	
		// Any pending subscriptions for this property will be completed with KErrNotFound.
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		r = prop.Attach(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		TRequestStatus status;
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNotFound);

		// Any new request will not complete until the property is defined and published again.
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		if (iType == RProperty::EInt)
			{
			r = prop.Set(1);
			TF_ERROR(r, r == KErrNone);
			}
		else
			{
			r = prop.Set(_L("Foo"));
			TF_ERROR(r, r == KErrNone);
			}
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNone);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		prop.Close();
		}
	}

_LIT(KPanicName, "RProperty Panics");

CPropPanic::CPropPanic(TUid aCategory, TUint aKey) : 
	  CTestProgram(KPanicName), iCategory(aCategory), iKey(aKey)
	{
	}

TInt CPropPanic::DoubleSubscribeThreadEntry(TAny* ptr)
	{
	CPropPanic* prog = (CPropPanic*) ptr;
	RProperty prop;
	TInt r = prop.Attach(prog->iCategory, prog->iKey, EOwnerThread);
	TF_ERROR_PROG(prog, r, r == KErrNone);
	TRequestStatus status;
	prop.Subscribe(status);
	// Next statement shall Panic.	
	prop.Subscribe(status);
	// Never get here
	return KErrNone;
	}

TInt CPropPanic::BadHandleSubscribeThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	TRequestStatus status;
	prop.Subscribe(status);
	return KErrNone;
	}

TInt CPropPanic::BadHandleCancelThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	prop.Cancel();
	return KErrNone;
	}

TInt CPropPanic::BadHandleGetIThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	TInt i;
	prop.Get(i);
	return KErrNone;
	}

TInt CPropPanic::BadHandleGetBThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	TBuf<64> buf;
	prop.Get(buf);
	return KErrNone;
	}

TInt CPropPanic::BadHandleSetIThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	TInt i = 1;
	prop.Set(i);
	return KErrNone;
	}

TInt CPropPanic::BadHandleSetBThreadEntry(TAny* /*ptr*/)
	{
	RProperty prop;
	TBuf<64> buf;
	prop.Set(buf);
	return KErrNone;
	}

TThreadFunction CPropPanic::BadHandles[] = {
	CPropPanic::BadHandleSubscribeThreadEntry,
	CPropPanic::BadHandleCancelThreadEntry,
	CPropPanic::BadHandleGetIThreadEntry,
	CPropPanic::BadHandleGetBThreadEntry,
	CPropPanic::BadHandleSetIThreadEntry,
	CPropPanic::BadHandleSetBThreadEntry,
	NULL
};

void CPropPanic::Run(TUint /* aCount */)
	{
	// Only one subscriptoin per RProperty object is allowed, the caller will be paniced if
	// there is already a subscription on this object.
	TRequestStatus status;
	TExitType exit;
	RThread thr;
	TInt r = thr.Create(KNullDesC, DoubleSubscribeThreadEntry, 0x2000, NULL, this);
	TF_ERROR(r, r == KErrNone);
	thr.Logon(status);

	TBool jit = User::JustInTime();
	User::SetJustInTime(EFalse);

	thr.Resume();
	User::WaitForRequest(status);
	thr.Close();

	User::SetJustInTime(jit);

	TF_ERROR(status.Int(), status.Int() == ERequestAlreadyPending);	

	for (TInt i = 0; BadHandles[i]; ++i)
		{
		r = thr.Create(KNullDesC, BadHandles[i], 0x2000, NULL, this);
		TF_ERROR(r, r == KErrNone);
		thr.Logon(status);

		jit = User::JustInTime();
		User::SetJustInTime(EFalse);

		thr.Resume();
		User::WaitForRequest(status);
		exit = thr.ExitType();
		thr.Close();

		User::SetJustInTime(jit);

		TF_ERROR(status.Int(), status.Int() == EBadHandle);	
		TF_ERROR(exit, exit == EExitPanic);
		}
	}

_LIT(KSetGetName, "RProperty::Set()/Get() Basics");

CPropSetGet::CPropSetGet(TUid aCategory, TUint aKey, RProperty::TType aType) : 
	  CTestProgram(KSetGetName), iCategory(aCategory), iKey(aKey), iType(aType)
	{
	}

void CPropSetGet::Run(TUint aCount)
	{
	for(TUint i = 0; i < aCount; ++i)
		{
		TInt r;
		RProperty prop;

		r = prop.Attach(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);

		// If the property has not been defined this fails with KErrNotFound.
			{
			TInt value;
			TBuf<16> buf;
			TBuf8<16> buf8;
			if (iType == RProperty::EInt)
				{
				r = prop.Get(iCategory, iKey, value);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(iCategory, iKey, value);
				TF_ERROR(r, r == KErrNotFound);
				}
			else
				{
				r = prop.Get(iCategory, iKey, buf);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(iCategory, iKey, buf);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Get(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrNotFound);
				}

			if (iType == RProperty::EInt)
				{
				r = prop.Get(value);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(value);
				TF_ERROR(r, r == KErrNotFound);
				}
			else
				{
				r = prop.Get(buf);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(buf);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Get(buf8);
				TF_ERROR(r, r == KErrNotFound);
				r = prop.Set(buf8);
				TF_ERROR(r, r == KErrNotFound);
				}
			}

		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);

		// Can set property to zero length
			{
			if (iType ==  RProperty::EByteArray)
				{
				TBuf8<20> buf8(20);
				r = prop.Set(iCategory, iKey, KNullDesC8);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrNone);
				TF_ERROR(buf8.Length(), buf8.Length() == 0);
				}
			}

		// If the property is larger than KMaxPropertySize this fails with KErrTooBig
			{
			if (iType ==  RProperty::EByteArray)
				{
				TBuf<RProperty::KMaxPropertySize/2 + 1> buf(RProperty::KMaxPropertySize/2 + 1);
				TBuf8<RProperty::KMaxPropertySize + 1> buf8(RProperty::KMaxPropertySize + 1);
				r = prop.Set(iCategory, iKey, buf);
				TF_ERROR(r, r == KErrTooBig);
				r = prop.Set(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrTooBig);
				r = prop.Set(buf);
				TF_ERROR(r, r == KErrTooBig);
				r = prop.Set(buf8);
				TF_ERROR(r, r == KErrTooBig);
				}
			}

		// When type of operation mismatch with the property type this fails with KErrArgument.
			{
			TInt value;
			TBuf<16> buf;
			TBuf8<16> buf8;
			if (iType !=  RProperty::EInt)
				{
				r = prop.Get(iCategory, iKey, value);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(iCategory, iKey, value);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Get(value);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(value);
				TF_ERROR(r, r == KErrArgument);
				}
			else
				{
				r = prop.Get(iCategory, iKey, buf);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(iCategory, iKey, buf);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Get(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(iCategory, iKey, buf8);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Get(buf);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(buf);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Get(buf8);
				TF_ERROR(r, r == KErrArgument);
				r = prop.Set(buf8);
				TF_ERROR(r, r == KErrArgument);
				}
			}

		// Get/Set
		if (iType == RProperty::EInt)
			{
				{
				r = prop.Set(1);
				TF_ERROR(r, r == KErrNone);
				TInt value = 0;
				r = prop.Get(value);
				TF_ERROR(r, r == KErrNone);
				TF_ERROR(value, value == 1);
				}
				{
				TInt value = 0;
				r = prop.Set(iCategory, iKey, 1);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, value);
				TF_ERROR(r, r == KErrNone);
				TF_ERROR(value, value == 1);
				}
			}
		else 
			{
				{
				TBuf<16> ibuf(_L("Foo"));
				TBuf<16> obuf;
				r = prop.Set(ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(obuf);
				TF_ERROR(r, r == KErrNone);
				r = obuf.Compare(ibuf);
				TF_ERROR(r, r == 0);
				}
				{
				TBuf8<16> ibuf8((TUint8*)"Foo");
				TBuf8<16> obuf8;
				r = prop.Set(ibuf8);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(obuf8);
				TF_ERROR(r, r == KErrNone);
				r = obuf8.Compare(ibuf8);
				TF_ERROR(r, r == 0);
				}
				{
				TBuf<16> ibuf(_L("Foo"));
				TBuf<16> obuf;
				r = prop.Set(iCategory, iKey, ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, obuf);
				TF_ERROR(r, r == KErrNone);
				r = obuf.Compare(ibuf);
				TF_ERROR(r, r == 0);
				}
				{
				TBuf8<16> ibuf8((TUint8*)"Foo");
				TBuf8<16> obuf8;
				r = prop.Set(iCategory, iKey, ibuf8);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, obuf8);
				TF_ERROR(r, r == KErrNone);
				r = obuf8.Compare(ibuf8);
				TF_ERROR(r, r == 0);
				}
			}

		// If the supplied buffer is too small this fails with KErrOverflow and the truncated value is reported.
		if (iType == RProperty::EByteArray)
			{
				{
				TBuf<16> ibuf(_L("0123456789012345"));
				TBuf<16> obuf(_L("abcdefghigklmnop"));
				TPtr optr((TUint16*) obuf.Ptr(), 0, 15);
				r = prop.Set(iCategory, iKey, ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, optr);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(optr.Length(), optr.Length() == 15); 
				TF_ERROR(obuf[14], obuf[14] == TText('4')); 
				TF_ERROR(obuf[15], obuf[15] == TText('p'));
				}
				{
				TBuf8<16> ibuf8((TUint8*) "0123456789012345");
				TBuf8<16> obuf8((TUint8*) "abcdefghigklmnop");
				TPtr8 optr8((TUint8*) obuf8.Ptr(), 0, 15);
				r = prop.Set(iCategory, iKey, ibuf8);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(iCategory, iKey, optr8);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(optr8.Length(), optr8.Length() == 15); 
				TF_ERROR(obuf8[14], obuf8[14] == '4'); 
				TF_ERROR(obuf8[15], obuf8[15] == 'p');
				}
				{
				TBuf<16> ibuf(_L("0123456789012345"));
				TBuf<16> obuf(_L("abcdefghigklmnop"));
				TPtr optr((TUint16*) obuf.Ptr(), 0, 15);
				r = prop.Set(ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(optr);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(optr.Length(), optr.Length() == 15); 
				TF_ERROR(obuf[14], obuf[14] == TText('4')); 
				TF_ERROR(obuf[15], obuf[15] == TText('p')); 
				}
				{
				TBuf8<16> ibuf8((TUint8*) "0123456789012345");
				TBuf8<16> obuf8((TUint8*) "abcdefghigklmnop");
				TPtr8 optr8((TUint8*) obuf8.Ptr(), 0, 15);
				r = prop.Set(ibuf8);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(optr8);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(optr8.Length(), optr8.Length() == 15); 
				TF_ERROR(obuf8[14], obuf8[14] == '4'); 
				TF_ERROR(obuf8[15], obuf8[15] == 'p');
				}
			}

		// Get/Set zero-length data
		if (iType == RProperty::EByteArray)
			{
				{
				TBuf<16> ibuf(_L("Foo"));
				TBuf<16> obuf;
				TPtr nullbuf(NULL, 0);

				r = prop.Set(ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(nullbuf);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(nullbuf.Length(), (nullbuf.Length() == 0));

				r = prop.Set(nullbuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(obuf);
				TF_ERROR(r, r == KErrNone);
				TF_ERROR(obuf.Length(), (obuf.Length() == 0));
				}
				{
				TBuf8<16> ibuf((TUint8*) "Foo");
				TBuf8<16> obuf;
				TPtr8 nullbuf(NULL, 0);

				r = prop.Set(ibuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(nullbuf);
				TF_ERROR(r, r == KErrOverflow);
				TF_ERROR(nullbuf.Length(), (nullbuf.Length() == 0));

				r = prop.Set(nullbuf);
				TF_ERROR(r, r == KErrNone);
				r = prop.Get(obuf);
				TF_ERROR(r, r == KErrNone);
				TF_ERROR(obuf.Length(), (obuf.Length() == 0));
				}
			}

		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
		prop.Close();
		}
	}

		
_LIT(KSubsCancelName, "RProperty::Subscribe()/Cancel() Basics");
 
CPropSubsCancel::CPropSubsCancel(TUid aCategory, TUint aKey, RProperty::TType aType) : 
	  CTestProgram(KSubsCancelName), iCategory(aCategory), iKey(aKey), iType(aType)
	{
	}


void CPropSubsCancel::Run(TUint aCount)
	{

	for(TUint i = 0; i < aCount; ++i)
		{
		TRequestStatus status;
		RProperty prop;

		TInt r = prop.Attach(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);

		// The calling thread will have the specified request status signalled when the property is next updated.
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		if (iType == RProperty::EInt)
			{
			r = prop.Set(1);
			TF_ERROR(r, r == KErrNone);
			}
		else
			{
			r = prop.Set(_L("Foo"));
			TF_ERROR(r, r == KErrNone);
			}
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNone);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);
	
		// If the property has not been defined, the request will not complete until the property
		// is defined and published.
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		if (iType == RProperty::EInt)
			{
			r = prop.Set(1);
			TF_ERROR(r, r == KErrNone);
			}
		else
			{
			r = prop.Set(_L("Foo"));
			TF_ERROR(r, r == KErrNone);
			}
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNone);
		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);

		// Cancel an outstanding subscription request for this property handle. 
		// If it has not already completed, the request is completed with KErrCancelled.
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		prop.Cancel();		
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrCancel);

		r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy);
		TF_ERROR(r, r == KErrNone);
		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		if (iType == RProperty::EInt)
			{
			r = prop.Set(1);
			TF_ERROR(r, r == KErrNone);
			}
		else
			{
			r = prop.Set(_L("Foo"));
			TF_ERROR(r, r == KErrNone);
			}
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrNone);
		prop.Cancel();		
		TF_ERROR(status.Int(), status.Int() == KErrNone);

		prop.Subscribe(status);
		TF_ERROR(status.Int(), status.Int() == KRequestPending);
		prop.Cancel();		
		User::WaitForRequest(status);
		TF_ERROR(status.Int(), status.Int() == KErrCancel);

		r = prop.Delete(iCategory, iKey);
		TF_ERROR(r, r == KErrNone);

		prop.Close();
		}
	}

_LIT(KSecurityName, "RProperty Security Basics (Master)");
 
CPropSecurity::CPropSecurity(TUid aCategory, TUint aMasterKey, RProperty::TType aType, TUint aSlaveKeySlot) : 
		CTestProgram(KSecurityName), iCategory(aCategory), iMasterKey(aMasterKey), 
		iSlaveKeySlot(aSlaveKeySlot), iType(aType)
	{
	}

_LIT(KSecuritySlavePath, "t_prop_sec.exe");

void CPropSecurity::Run(TUint aCount)
	{
	for(TInt i=0; i<ECapability_Limit; i++)
		if(!PlatSec::IsCapabilityEnforced((TCapability)i))
			{
			// System isn't configured with platform security enforced
			// so don't bother running tests
			return;
			}

	TArgs args;
	args.iCount = aCount;
	args.iCategory = iCategory;
	args.iMasterKey = iMasterKey;
	args.iSlaveKeySlot = iSlaveKeySlot;

	RProperty prop;

	TInt r = prop.Define(iCategory, iMasterKey, iType, KPassPolicy, KPassPolicy);
	TF_ERROR(r, r == KErrNone);

	Exec(KSecuritySlavePath, &args, sizeof(args));

	Exec(_L("t_prop_define0.exe"), &args, sizeof(args));
	Exec(_L("t_prop_define1.exe"), &args, sizeof(args));
	Exec(_L("t_prop_define2.exe"), &args, sizeof(args));
	Exec(_L("t_prop_define3.exe"), &args, sizeof(args));

	r = prop.Delete(iCategory, iMasterKey);
	TF_ERROR(r, r == KErrNone);
	}