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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code 

*/

#include <e32std.h>

#include <hal.h>

#include <u32hal.h>

#include <graphics/surfaceupdateclient.h>

#include <graphics/suerror.h>

#include <limits.h>

#include "surfaceupdatetest.h"

#include "tsurfaceupdate.h"

#include "surfaceupdate.h"

CTSurfaceUpdate::CTSurfaceUpdate(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

CTSurfaceUpdate::~CTSurfaceUpdate()

	{

	while (iReceivers.Count())

		{

		CTContentUpdateReceiver *receiver = iReceivers[0];

		iReceivers.Remove(0);

		CloseTestUpdateReceiver(receiver);

		}

	iReceivers.Reset();	

	}

void CTSurfaceUpdate::ConstructL()

	{

	SetupContentUpdateReceiversL();

	}

void CTSurfaceUpdate::SetupContentUpdateReceiversL()

	{

	//first receiver

	CTContentUpdateReceiver *receiver;

	User::LeaveIfError(StartTestUpdateReceiver(receiver, 1));

	iReceivers.AppendL(receiver);

	//second receiver

	CTContentUpdateReceiver *receiver2;

	User::LeaveIfError(StartTestUpdateReceiver(receiver2, 2));

	iReceivers.AppendL(receiver2);

	//third receiver

	CTContentUpdateReceiver *receiver3;

	User::LeaveIfError(StartTestUpdateReceiver(receiver3, 3));

	iReceivers.AppendL(receiver3);

	User::LeaveIfError(Provider()->Register(0, receiver, -1));

	User::LeaveIfError(Provider()->Register(1, receiver2, 1));

	User::LeaveIfError(Provider()->Register(2, receiver3, 2));

	}

/**

  @SYMTestCaseID GRAPHICS-SURFACEUPDATE-0001

  @SYMPREQ 1007

  @SYMREQ 8223

  @SYMTestCaseDesc Initialization of the server environment twice.

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Attempt to start the server for the second time.

  @SYMTestExpectedResults Must return KErrAlreadyExists.

*/

void CTSurfaceUpdate::TestCase1()

	{

	INFO_PRINTF1(_L("Attempt to start the server for the second time"));

	MSurfaceUpdateServerProvider *surfaceUpdateProvider = NULL;

	TInt res = StartSurfaceUpdateServer(surfaceUpdateProvider);

	TEST(res==KErrNone);

	TEST(surfaceUpdateProvider!=NULL);

	TEST(surfaceUpdateProvider==Provider());

	}

/**

  @SYMTestCaseID GRAPHICS-SURFACEUPDATE-0002

  @SYMPREQ 1007

  @SYMREQ 8223

  @SYMTestCaseDesc Submit update commands and subscribe for notifications. 

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Create connection to the server. 

  		Subscribe for different notifications (consumed, displayed, displayedXTimes). 

  		Submit update command. Wait for notifications to arrive. 

  		Repeat for a few times in a row .

  @SYMTestExpectedResults Errors, which will be conveyed in 

  TRequestStatus must be equal to KErrNone. The order must be consistent with 

  before and after submission (Before submission < composition < after submission). 

*/

void CTSurfaceUpdate::TestCase2L()

	{

	INFO_PRINTF1(_L("Submit update and subscribe for notifications"));

	const TInt KMaxSubmissionNumber = 60; //it should be divisible by 3!

	RSurfaceUpdateSession session;

	TInt res = session.Connect();

	User::LeaveIfError(res);

	iSurfaceOrder = CRequestOrder::NewL(KMaxSubmissionNumber);

	iReceivers[0]->SetCompositionOrder(iSurfaceOrder);

	iReceivers[1]->SetCompositionOrder(iSurfaceOrder);

	iReceivers[2]->SetCompositionOrder(iSurfaceOrder);

	TInt screen = 0;

	TInt buffer = 2;

	TSurfaceId surface = 

		{

		1,2,3,4

		};

	TRect rc[2] =

			{

			TRect(1,2, 10, 20),

			TRect(5,6, 30, 30)

			};

	RRegion region(2, rc);

	// Test that submitting for an update before any noitfications causes no problems

	TEST(KErrNone == session.SubmitUpdate(screen, surface, buffer, &region));

	iSurfaceOrder->ResetAll();

	for(TInt submissionNumber = 0; submissionNumber < KMaxSubmissionNumber/3; submissionNumber++)

		{

		INFO_PRINTF2(_L("Submission number %d"), submissionNumber+1);	

		TRequestStatus status = KRequestPending;

		TRequestStatus status1 = KRequestPending;

		TRequestStatus status2 = KRequestPending;

		TTimeStamp timeStamp; 

		iSurfaceOrder->SetOrder(EOrderBefore);

		session.NotifyWhenAvailable(status);	

		session.NotifyWhenDisplayed(status1, timeStamp);	

		session.NotifyWhenDisplayedXTimes(10, status2);

		res = session.SubmitUpdate(screen, surface, buffer, &region);

		TEST(res==KErrNone);

		User::WaitForRequest(status);

		User::WaitForRequest(status1);

		User::WaitForRequest(status2);

		iSurfaceOrder->SetOrder(EOrderAfter);

		TEST(status == KErrNone);

		TEST(status1 == KErrNone);

		TEST(status2 == KErrNone);

		}

    for(TInt i=0; i < KMaxSubmissionNumber/3; i++)

        {

        TInt positionBefore=-1;

        TInt positionComposition=-1;

        TInt positionAfter=-1;

        for(TInt j=0; j < KMaxSubmissionNumber; j++)

            {

            if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderBefore))

                {

                positionBefore=j;

                }

            if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderComposition))

                {

                positionComposition=j;

                }

            if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderAfter))

                {

                positionAfter=j;

                }

            }

        TEST((positionBefore != -1) && (positionComposition != -1) && (positionAfter != -1));

        TEST(positionBefore < positionComposition);

        TEST(positionAfter > positionComposition);

        }

	delete iSurfaceOrder;

	iSurfaceOrder = NULL;

	iReceivers[0]->SetCompositionOrder(NULL);

	iReceivers[1]->SetCompositionOrder(NULL);

	iReceivers[2]->SetCompositionOrder(NULL);

	session.Close();

	}

/**

  @SYMTestCaseID GRAPHICS-SURFACEUPDATE-0003

  @SYMPREQ 1007

  @SYMREQ 8223

  @SYMTestCaseDesc Submit a few requests, then consume them. 

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions A. Request notifications of the same type consecutively 

  	(no submit in-between) and check that the behaviour is correct.

    B. Create connection to the server with sufficient number of 

  	outstanding asynchronous message slots. 

  	1. Subscribe for different notifications (consumed, displayed, 

  	displayedXTimes). 

  	2. Submit update command. 

  	3 Repeat step 1 & 2 a few times. 

  	Wait for notifications (from all requests) to arrive. 

  	Repeat 1& 2 & 3 a few times in a row

  @SYMTestExpectedResults A. The last of each notification request type 

  to be issued before the submission will return with KErrNone, as will 

  the SubmitUpdate. B. Errors, which will be conveyed in TRequestStatus 

  must be equal to KErrNone. The order must be consistent with 

  before and after submission (Before submission < composition < after submission).  

*/

void CTSurfaceUpdate::TestCase3L()

	{

	INFO_PRINTF1(_L("Submission a few update requests in  a row, then waiting for notifications to arrive"));

	RSurfaceUpdateSession session;

	const TInt KNumberAsynchronousRequests = 42; //it should be divisible by 3!

	TInt res = session.Connect(KNumberAsynchronousRequests);

	INFO_PRINTF2(_L("Set number of outstanding asynchronous requests as: %d"), KNumberAsynchronousRequests);	

	User::LeaveIfError(res);

	iSurfaceOrder = CRequestOrder::NewL(KNumberAsynchronousRequests);

	iReceivers[0]->SetCompositionOrder(iSurfaceOrder);

	iReceivers[1]->SetCompositionOrder(iSurfaceOrder);

	iReceivers[2]->SetCompositionOrder(iSurfaceOrder);

	TInt screen = 0;

	TInt screen1 = 1;

	TInt buffer = 2;

	TSurfaceId surface = 

		{

		1,2,3,4

		};

	TRect rc[] =

			{

			TRect(1,2, 3, 4),

			TRect(5,6, 7, 8),

			TRect(9, 10, 11, 12),

			TRect(13, 14, 15, 16),

			};

	RRegion region(4, rc);

	// Test calling two notifies in a row followed by a submit

	TRequestStatus stat[6];

	session.NotifyWhenAvailable(stat[0]);

	session.NotifyWhenAvailable(stat[1]);

	TTimeStamp tStamp[2];

	session.NotifyWhenDisplayed(stat[2], tStamp[0]);

	session.NotifyWhenDisplayed(stat[3], tStamp[1]);

	session.NotifyWhenDisplayedXTimes(10, stat[4]);

	session.NotifyWhenDisplayedXTimes(10, stat[5]);	

	TEST(KErrNone == session.SubmitUpdate(0 , surface, buffer, &region));

	// The last requests for notification will be fulfilled, the others ignored

	User::WaitForRequest(stat[1]);

	User::WaitForRequest(stat[3]);

	User::WaitForRequest(stat[5]);	

	TEST(stat[1] == KErrNone);

	TEST(stat[3] == KErrNone);

	TEST(stat[5] == KErrNone);

	// Submit a few requests, then consume them

	for(TInt index1 = 0; index1 < 5; index1++)

		{

		INFO_PRINTF2(_L("Attempt number %d"), index1+1);	

		TRequestStatus status[KNumberAsynchronousRequests];

		TTimeStamp timeStamp[KNumberAsynchronousRequests];

		// Reset all values

		iSurfaceOrder->ResetAll();

		for(TInt index2 = 0; index2 < KNumberAsynchronousRequests; index2 += 3)

			{

			INFO_PRINTF2(_L("Submission number %d"), index2 / 3 + 1);	

			status[index2]=KRequestPending;

			session.NotifyWhenAvailable(status[index2]);	

			status[index2 + 1]=KRequestPending;

			session.NotifyWhenDisplayed(status[index2 + 1], timeStamp[index2 / 3]);	

			status[index2 + 2]=KRequestPending;

			session.NotifyWhenDisplayedXTimes(10, status[index2 + 2]);

			iSurfaceOrder->SetOrder(EOrderBefore);

			res = session.SubmitUpdate((index2 % 2) ? screen : screen1, surface, buffer, &region);

			TEST(res==KErrNone);

			}

		for(TInt submissionNumber = 0; submissionNumber < KNumberAsynchronousRequests; submissionNumber++)

			{

			User::WaitForRequest(status[submissionNumber]);

			TEST(status[submissionNumber] == KErrNone);

			if(((submissionNumber - 1) % 3) == 0)

				{

				iSurfaceOrder->SetOrder(EOrderAfter);

				}

			}

		for(TInt i=0; i < KNumberAsynchronousRequests/3; i++)

			{

			TInt positionBefore=-1;

			TInt positionComposition=-1;

			TInt positionAfter=-1;

			for(TInt j=0; j < KNumberAsynchronousRequests; j++)

				{

				if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderBefore))

					{

					positionBefore=j;

					}

				if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderComposition))

					{

					positionComposition=j;

					}

				if((iSurfaceOrder->GetOrderNumber(j) == i) && (iSurfaceOrder->GetOrderType(j) == EOrderAfter))

					{

					positionAfter=j;

					}

				}

			TEST((positionBefore != -1) && (positionComposition != -1) && (positionAfter != -1));

			TEST(positionBefore < positionComposition);

			TEST(positionAfter > positionComposition);

			}

		}

	delete iSurfaceOrder;

	iSurfaceOrder = NULL;

	iReceivers[0]->SetCompositionOrder(NULL);

	iReceivers[1]->SetCompositionOrder(NULL);

	iReceivers[2]->SetCompositionOrder(NULL);

	session.Close();

	}

/**

  @SYMTestCaseID GRAPHICS-SURFACEUPDATE-0004

  @SYMPREQ 1007

  @SYMREQ 8223

  @SYMTestCaseDesc Cancellation of the requests. 

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Create connection to the server.

  	1. Test cancellation without SubmitUpdate

    2. Check cancellation before submission does nothing bad.

  	3. Subscribe for different notifications (consumed, displayed, 

  	displayedXTimes). 

  	4. Submit update command. 5. Repeat steps 3 & 4 a few times. 

  	Cancel all outstanding notifications. Wait for cancelled notifications 

  	to arrive.

  @SYMTestExpectedResults Notifications must arrive straightway with 

  KErrCancel error code or KErrNone, if events have already occurred.

*/

void CTSurfaceUpdate::TestCase4L()

	{

	INFO_PRINTF1(_L("Submission a few requests in a row and then cancelling them"));

	RSurfaceUpdateSession session;

	const TInt KNumberAsynchronousRequests = 99; //should be divisible by 3!

	TInt res = session.Connect(KNumberAsynchronousRequests);

	INFO_PRINTF1(_L("Test CancelAllUpdateNotifications without SubmitUpdate"));

	// Test CancelAllUpdateNotifications without SubmitUpdate

	TRequestStatus status1, status2, status3;

	TTimeStamp ts;

	session.NotifyWhenAvailable(status1);

	session.NotifyWhenDisplayed(status2, ts);

	session.NotifyWhenDisplayedXTimes(5, status3);

	session.CancelAllUpdateNotifications();

	User::WaitForRequest(status1);

	User::WaitForRequest(status2);

	User::WaitForRequest(status3);

	TEST(status1==KErrCancel);

	TEST(status2==KErrCancel);

	TEST(status3==KErrCancel);

	INFO_PRINTF2(_L("Set number of outstanding asynchronous requests as: %d"), KNumberAsynchronousRequests);	

	User::LeaveIfError(res);

	TInt screen = 0;

	TInt screen1 = 1;

	TInt buffer = 2;

	TSurfaceId surface = 

		{

		1,2,3,4

		};

	TRect rc[] =

			{

			TRect(1,2, 3, 4),

			TRect(5,6, 7, 8),

			TRect(9, 10, 11, 12),

			TRect(13, 14, 15, 16),

			};

	RRegion region(4, rc);

	// Check that cancelling notifications before any submission does nothing bad

	session.CancelAllUpdateNotifications();

	for(TInt index1 = 0; index1 < 2; index1++)

		{

		INFO_PRINTF2(_L("Attempt number %d"), index1+1);	

		TRequestStatus status[KNumberAsynchronousRequests];

		TTimeStamp timeStamp[KNumberAsynchronousRequests];

		TUint64 timestampComposition[KNumberAsynchronousRequests];

		TUint64 timestampBefore[KNumberAsynchronousRequests];

		TUint64 timestampAfter[KNumberAsynchronousRequests];

		for(TInt index2 = 0; index2 < KNumberAsynchronousRequests; index2 += 3)

			{

			INFO_PRINTF2(_L("Submission number %d"), index2 / 3 + 1);	

			status[index2]=KRequestPending;

			session.NotifyWhenAvailable(status[index2]);	

			status[index2 + 1]=KRequestPending;

			session.NotifyWhenDisplayed(status[index2 + 1], timeStamp[index2 / 3]);	

			status[index2 + 2]=KRequestPending;

			session.NotifyWhenDisplayedXTimes(10, status[index2 + 2]);	

			timestampBefore[index2 / 3] = User::FastCounter();	

			res = session.SubmitUpdate((index2 % 2) ? screen : screen1, surface, buffer, &region);

			TEST(res==KErrNone);

			}

		TBool cancel=EFalse;

		session.CancelAllUpdateNotifications();

		for(TInt submissionNumber = 0; submissionNumber < KNumberAsynchronousRequests; submissionNumber++)

			{

			User::WaitForRequest(status[submissionNumber]);

			TEST((status[submissionNumber] == KErrCancel) || (status[submissionNumber] == KErrNone) );

			if(status[submissionNumber] == KErrCancel)

				{

				cancel = ETrue;

				}

			if((status[submissionNumber] == KErrNone) && ((submissionNumber - 1) % 3) == 0)

				{

				TInt index22 = submissionNumber / 3;

				timestampAfter[index22] = User::FastCounter();	

				if(timestampAfter[index22] < timestampBefore[index22])

					{

					timestampAfter[index22] += UINT_MAX;

					}

				timestampComposition[index22] = timeStamp[index22]();

				if(timestampComposition[index22] < timestampBefore[index22])

					{

					timestampComposition[index22] += UINT_MAX;

					}

				TEST(timestampComposition[index22] != 0);

				TEST(timestampAfter[index22] >= timestampComposition[index22]);

				TEST(timestampBefore[index22] <= timestampComposition[index22]);

				}

			}

		TEST(cancel);		

		}

		session.Close();

	}

/**

  @SYMTestCaseID GRAPHICS-SURFACEUPDATE-0005

  @SYMPREQ 1007

  @SYMREQ 8223

  @SYMTestCaseDesc Submission from multiple sessions. 

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Create a few connections to the server. For each connection: 

  		1. Subscribe for different notifications (consumed, displayed, 

  		displayedXTimes). 

  		2. Submit update command. Wait for notifications to arrive.

  @SYMTestExpectedResults Errors, which will be conveyed in 

  TRequestStatus must be equal to KErrNone. Timestamps must be consistent 

  with time before and after submissions.

*/

void CTSurfaceUpdate::TestCase5L()