// 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 <e32test.h>

#include "t_property.h"

_LIT(KTestName,"t_stress_property");

RTest test(KTestName);

const TInt32 KUidPropTestCategoryValue = 0x101f75b8;

const TUid KPropTestCategory = { KUidPropTestCategoryValue };

#define TEST_TIME 36000			//10 hours

#define TEST_ERROR(rl,rr) { if((TInt)rl!=(TInt)rr) { ExitThread(rl, rr, __LINE__); return KErrGeneral; } }

TBool volatile StopAndExit = EFalse;

TTime startTime;

LOCAL_D void ExitThread(TInt rl, TInt rr, TInt aLine)

	{

	test.Printf(_L("Test '%S' failed at line %d; Expected value=%d Actual value=%d; \n"), &KTestName, aLine, rr, rl);

	StopAndExit = ETrue;

	//delete if it's not deleted, to wake up subscribing threads waiting for events on this property

	RProperty::Delete(KPropTestCategory,0);

	}

LOCAL_D TInt LowPriorityThread1(TAny* /*aParameter*/)

	{

	RProperty prop;

	TBuf8<512> buffer;

	TInt length = 2;

	TInt r=prop.Attach(KPropTestCategory,0);

	TEST_ERROR(r,KErrNone);

	while(!StopAndExit)

		{

		buffer.SetLength(length);

		buffer[0]=(TUint8)(length%256);

		buffer[length-1]=(TUint8)((length-1)%256);

		++length;

		if(length>512)

			length=2;

		r=prop.Set(buffer);

		if(r!=KErrArgument && r!=KErrNotFound)

			{

			//if it's not of type EInt and defined

			TEST_ERROR(r,KErrNone);

			}

		User::AfterHighRes(0);

		}

	return KErrNone;

	}

LOCAL_D TInt LowPriorityThread2(TAny* /*aParameter*/)

	{

	RProperty prop;

	TBuf8<512> buffer;

	TInt r=prop.Attach(KPropTestCategory,0);

	TEST_ERROR(r,KErrNone);

	while(!StopAndExit)

		{

		r=prop.Get(buffer);

		if(r!=KErrArgument && r!=KErrNotFound)

			{

			//if it's not of type EInt and defined

			TEST_ERROR(r,KErrNone);

			TInt length=buffer.Length();

			if(length>0)

				{

				TEST_ERROR(buffer[0],length%256);

				TEST_ERROR(buffer[length-1],(length-1)%256);

				}

			}

		}

	return KErrNone;

	}

LOCAL_D TInt MediumPriorityThread(TAny* /*aParameter*/)

	{

	RProperty prop;

	TBuf8<512> buffer;

	TInt r=prop.Attach(KPropTestCategory,0);

	TEST_ERROR(r,KErrNone);

	TRequestStatus status;

	while(!StopAndExit)

		{

		prop.Subscribe(status);

		User::WaitForRequest(status);

		if(StopAndExit)

			break;

		if(status.Int() != KErrNotFound)

			{

			//property is defined

			TEST_ERROR(status.Int(),KErrNone);

			r=prop.Get(buffer);

			if(r!=KErrArgument)

				{

				TEST_ERROR(r,KErrNone);

				TInt length=buffer.Length();

				if(length>0)

					{

					TEST_ERROR(buffer[0],length%256);

					TEST_ERROR(buffer[length-1],(length-1)%256);

					}

				}

			}

		}

	return KErrNone;

	}

LOCAL_D TInt HighPriorityThread(TAny* /*aParameter*/)

	{

	TInt type=RProperty::EInt;

	TInt iteration=0;

	TInt r;

	while(!StopAndExit)

		{

		User::AfterHighRes(1000); //wait for 1ms

//		test.Printf(_L("Deleting property\r\n"));

		r=RProperty::Delete(KPropTestCategory,0);

		TEST_ERROR(r,KErrNone);

//		test.Printf(_L("Defining property\r\n"));

		r=RProperty::Define(KPropTestCategory,0,type, KPassPolicy, KPassPolicy);

		TEST_ERROR(r,KErrNone);

		type=(type+1)%RProperty::ETypeLimit;

		if(1000 == ++iteration)

			{

			//check if we should exit

			TTimeIntervalSeconds timeTaken;

			TTime time;

			time.HomeTime();

			TInt r = time.SecondsFrom(startTime, timeTaken);

			TEST_ERROR(r,KErrNone);

			if(timeTaken.Int() >= TEST_TIME)

				{

				//we should exit

				StopAndExit=ETrue;

				//delete if it's not deleted, to wake up subscribing threads waiting for events on this property

				RProperty::Delete(KPropTestCategory,0);

				break;

				}

			iteration=0;

			}

		}

	return KErrNone;

	}

GLDEF_C TInt E32Main()

	{

	test.Start(_L("Stress test using multiple threads accessing the same property"));

    startTime.HomeTime();

	TInt r=RProperty::Define(KPropTestCategory,0,RProperty::EInt, KPassPolicy, KPassPolicy);

	test(r==KErrNone);

	TRequestStatus status1;

	TRequestStatus status2;

	TRequestStatus status3;

	TRequestStatus status4;

	RThread t1;

	RThread t2;

	RThread t3;

	RThread t4;

	r = t1.Create(KNullDesC, LowPriorityThread1, 0x2000, NULL, 0);

	test(r == KErrNone);

	t1.SetPriority(EPriorityLess);

	t1.Logon(status1);

	r = t2.Create(KNullDesC, LowPriorityThread2, 0x2000, NULL, 0);

	test(r == KErrNone);

	t2.SetPriority(EPriorityLess);

	t2.Logon(status2);

	r = t3.Create(KNullDesC, MediumPriorityThread, 0x2000, NULL, 0);

	test(r == KErrNone);

	t3.SetPriority(EPriorityNormal);

	t3.Logon(status3);

	r = t4.Create(KNullDesC, HighPriorityThread, 0x2000, NULL, 0);

	test(r == KErrNone);

	t4.SetPriority(EPriorityMore);

	t4.Logon(status4);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	t1.Resume();

	t2.Resume();

	t3.Resume();

	t4.Resume();

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::WaitForRequest(status3);

	User::WaitForRequest(status4);

	User::SetJustInTime(jit);

	test(status1 == KErrNone);

	test(status2 == KErrNone);

	test(status3 == KErrNone);

	test(status4 == KErrNone);

	TTimeIntervalSeconds timeTaken;

	TTime time;

	time.HomeTime();

	r = time.SecondsFrom(startTime, timeTaken);

	test(r==KErrNone);

	TInt totalTime = timeTaken.Int();

	TInt seconds = totalTime % 60;

    TInt minutes = (totalTime / 60) % 60;

    TInt hours   = totalTime / 3600;

    test.Printf(_L("Time taken since test started: %d:%d:%d\r\n"), 

                   hours, minutes, seconds);

	CLOSE_AND_WAIT(t1);

	CLOSE_AND_WAIT(t2);

	CLOSE_AND_WAIT(t3);

	CLOSE_AND_WAIT(t4);

	test.End();

	return KErrNone;

	}