/*
* Copyright (c) 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 "egltest_endpointstreamingtests.h"
#include "egltest_surface.h"


static const TTestCase KStreamingTestCases[] =
{
    {
        TESTIDS("582"),
        CASETITLE("Functional: Streaming: aStatusDisplayed behaves properly within streaming block"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 50000 },
        { EContentUpdateCase,   0, EGL_SUCCESS },
        { EBeginStreamingCase,  0, EGL_SUCCESS },
        { ETimeStampCase,       0, KErrNone },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNone, 0, ENotifyWhenDisplayed, 55000, 50000 },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 100000 },
        { ETimeStampCase,       0, KErrNone },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNone, 0, ENotifyWhenDisplayed, 110000, 100000 },
        { EEndStreamingCase,    0, EGL_SUCCESS },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
    {
        TESTIDS("584"),
        CASETITLE("Functional: Streaming: aStatusDisplayed behaves properly outside of streaming block"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 50000 },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNotVisible, 0, ENotifyWhenDisplayed, 55000 },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNotVisible, 0, ENotifyWhenDisplayed, 5000 },
        { EEndStreamingCase,    0, EGL_SUCCESS },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
    {
        TESTIDS("585"),
        CASETITLE("Functional: Streaming: aStatusDisplayedXTimes behaves properly outside streaming block"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 50000 },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDispXTimes, 2 },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNotVisible, 0, ENotifyWhenDispXTimes, 5000 },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDispXTimes, 10 },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNotVisible, 0, ENotifyWhenDispXTimes, 5000 },
        { EEndStreamingCase,    0, EGL_SUCCESS },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
    {
        TESTIDS("586"),
        CASETITLE("Functional: Streaming: Additional SubmitUpdate issued before aStatusDisplayed is notified results in error KErrOverflow"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 20000 },
        { EContentUpdateCase,   0, EGL_SUCCESS },
        { EBeginStreamingCase,  0, EGL_SUCCESS },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrOverflow, 0, ENotifyWhenDisplayed, 10000 },
        { EEndStreamingCase,    0, EGL_SUCCESS },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
    {
        TESTIDS("587A"),
        CASETITLE("Functional: Streaming: aStatusDisplayed behaves properly on transition out of streaming block (variant 1)"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 20000 },
        { EContentUpdateCase,   0, EGL_SUCCESS },
        { EBeginStreamingCase,  0, EGL_SUCCESS },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNone, 0, ENotifyWhenDisplayed, 25000 },
        { EEndStreamingCase,    0, EGL_SUCCESS },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNotVisible, 0, ENotifyWhenDisplayed, 25000 },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
    {
        TESTIDS("587B"),
        CASETITLE("Functional: Streaming: aStatusDisplayed behaves properly on transition out of streaming block (variant 2)"),
        SurfaceTypes2(ESurfTypeRaw, ESurfTypeRawSingleBuffered),
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateSurfaceCase,   0, EGL_SUCCESS, 0, EStandardSurface },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 20000 },
        { EContentUpdateCase,   0, EGL_SUCCESS },
        { EBeginStreamingCase,  0, EGL_SUCCESS },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrNone, 0, ENotifyWhenDisplayed, 25000 },
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ENotifyWhenCase,      0, KErrNone, 0, ENotifyWhenDisplayed },
        { EContentUpdateCase,   ENoWait, EGL_SUCCESS },
        { EWaitForCase,         0, KErrSurfaceNotRegistered, 0, ENotifyWhenDisplayed, 25000 },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase }
        },
    },
};


static const TTestCases KTestCases[] =
{
    TestCase(KStreamingTestCases),
};

const TInt KNumberTestCases = sizeof(KTestCases) / sizeof(KTestCases[0]);


CEglTest_LocalTestStep_EndpointStreamingTests::CEglTest_LocalTestStep_EndpointStreamingTests():
    CEgltest_Local_Engine(KTestCases, KNumberTestCases)
    {
    }


//------------------------------------------------------
// GRAPHICS-EGL-583 can only be implemented with code...
//------------------------------------------------------


CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream()
: CLocalTestStepBase(ETestUidEndpointEngine)  // We use the engine to do the remote side functionality.
    {
    }

void CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::DoPreambleL()
    {
    }

void CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::DoPostambleL()
    {
    }

CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::~CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream()
    {
    }

void CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::RunScript(const TEngineTestCase *aTestCases, TRemoteTestParams &params)
    {
    for(TInt i = 0; aTestCases[i].iCase != EFinishedCase; i++)
        {
        params.iEndpointEngine.iEngineTestCase = aTestCases[i];
        RunRemoteTestCase(aTestCases[i].iCase, params);
        }
    }

TUint CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::TicksForDisplayXTimesL(CSurface* aSurface, TInt aNumTimes)
    {
    //Calculate timeout by assuming low framerate of 10 fps, 
    //multiplying period by number of times and an extra factor of 3.
    //This should be plenty. Measured in microseconds.
    TInt timeout = 3 * aNumTimes * TInt(1000000.0f / 10.0f);
    
    TRequestStatus dispXTimesRs;
    User::LeaveIfError(aSurface->Notify(ENotifyWhenDispXTimes, dispXTimesRs, aNumTimes));
    
    TUint startTickCount = User::TickCount();
    User::LeaveIfError(aSurface->SubmitContent(EFalse));
    
    TUint32 dummyTimeStamp;
    TInt err = aSurface->WaitFor(ENotifyWhenDispXTimes, dispXTimesRs, timeout, dummyTimeStamp);
    if(err != KErrNone)
        {
        ERR_PRINTF3(_L("Waiting for ENotifyWhenDispXTimes returned %d when we expected %d."), err, KErrNone);
        User::Leave(err);
        }
    
    return User::TickCount() - startTickCount;
    }
    
void CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::DispXTimesInStreamTestL(TSurfaceType aSurfaceType)
    {
    //Local: Create surface and save the id for the remote side.
    CSurface* surface = CSurface::SurfaceFactoryL(aSurfaceType);
    CleanupStack::PushL(surface);
    surface->CreateL(EStandardSurface);
    surface->GetSurfaceParamsL(iParams.iEndpointEngine.iSurfaceParams);
    
    //Remote: Init remote side and create an endpoint from the surface. (tidy up ops are on cleanup stack)
    static const TEngineTestCase createEndpointSteps[] = 
        {
        { EInitializeCase,      0, EGL_SUCCESS },
        { ECreateEndpointCase,  0, EGL_SUCCESS },
        { EFinishedCase,        0, EGL_SUCCESS },
        };
    RunScript(createEndpointSteps, iParams);
    CleanupStack::PushL(TCleanupItem(CleanupRemoteTestStep, this));
    
    //Local: Submit update for the surface so that the endpoint enters the ready state.
    User::LeaveIfError(surface->SubmitContent(ETrue));
    
    //Remote: Set the EGL_DELAY_NOK value and begin streaming on the endpoint.
    static const TEngineTestCase setDelayAndBeginStreamingSteps[] = 
        {
        { ESetAttribCase,       0, EGL_SUCCESS, 0, 0, EGL_DELAY_NOK, 5000 },
        { EBeginStreamingCase,  0, EGL_SUCCESS },
        { EFinishedCase,        0, EGL_SUCCESS },
        };
    RunScript(setDelayAndBeginStreamingSteps, iParams);
    
    //Local: Get number of ticks between submitting content and X frames being displayed.
    TUint ticksForDisp20Times = TicksForDisplayXTimesL(surface, 20);
    INFO_PRINTF2(_L("ticksForDisp20Times = %d"), ticksForDisp20Times);
    TUint ticksForDisp200Times = TicksForDisplayXTimesL(surface, 200);
    INFO_PRINTF2(_L("ticksForDisp200Times = %d"), ticksForDisp200Times);
    
    //check to see if ticksForDisp200Times = 10 * ticksForDisp20Times (with some fuzz).
    if( (ticksForDisp200Times < 5*ticksForDisp20Times) || (ticksForDisp200Times > 15*ticksForDisp20Times) )
        {
        ERR_PRINTF1(_L("Ratio between time for display 20 times and display 200 times not within limits."));
        User::Leave(EFail);
        }
    else
        {
        INFO_PRINTF1(_L("Ratio between time for display 20 times and display 200 times is within limits."));
        }
    
    CleanupStack::PopAndDestroy(2, surface);
    }

TVerdict CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::doTestStepL()
    {
    static const TRemoteTestParams nullParams = {};
    StartRemoteTestStep(nullParams);
    
    DispXTimesInStreamTestL(ESurfTypeRaw);
    DispXTimesInStreamTestL(ESurfTypeRawSingleBuffered);
    
    EndRemoteTestStep(nullParams);
    INFO_PRINTF1(_L("EndpointStreamingDispXTimesInStream test finished"));
    return TestStepResult();
    }

void CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream::CleanupRemoteTestStep(TAny* aStreamingDispXTimesInStream)
    {
    CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream* self = 
                static_cast<CEglTest_LocalTestStep_EndpointStreamingDispXTimesInStream*>(aStreamingDispXTimesInStream);
    
    //Remote: Destroy the endpoint and terminate EGL.
    static const TEngineTestCase destroyEndpointSteps[] = 
        {
        { EDestroyEndpointCase, 0, EGL_SUCCESS },
        { ETerminateCase,       0, EGL_SUCCESS },
        { EFinishedCase },
        };
    self->RunScript(destroyEndpointSteps, self->iParams);
    }