// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and/or associated documentation files (the

// "Materials"), to deal in the Materials without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Materials, and to

// permit persons to whom the Materials are furnished to do so, subject to

// the following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Materials.

//

// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

//

// Description:

// Implementation of test class for OpenWF-C RI display driver interface 

//

#include <WF/openwfc_ri_display.h>

#include <WF/openwfc_ri_display_update.h>

#include <test/extendtef.h>

#include <test/tefunit.h>

#include <hal.h>

#include "tscreeninterface.h"

#define KCompositorVersion 0x01023456

#define KRgbRed         TRgb(0x0000ff)

#define KRgbGreen       TRgb(0x00ff00)

#define KRgbYellow      TRgb(0x00ffff)

#define KRgbBlue        TRgb(0xff0000)

const TInt KDefaultScreenNumber = 0;

const TTimeIntervalMicroSeconds32 KDelay = 1000000;  //delay in microseconds

const TTimeIntervalMicroSeconds32 KMinimalDelay = 1000;  //delay in microseconds

_LIT(KImageSectionName, "ImageInfo");

_LIT(KContiguousFlag, "ContiguousFlag");

_LIT(KNonFastpathablePixelFormat, "NonFastpathablePixelFormat");

_LIT(KFastpathablePixelFormat, "FastpathablePixelFormat");

/*

 * CTestScreenInterface implementation

 */

CTestScreenInterface::CTestScreenInterface()

:iContiguous(EFlagNotListed),

 iFastpathablePixelFormat(EUidPixelFormatARGB_8888_PRE),

 iNonFastpathablePixelFormat(EUidPixelFormatRGB_565),

 iMappable(ETrue),

 iMaxBuffers(2),

 iMinBuffers(1),

 iCacheAttrib(ECacheNotlisted)

	{

	// No implementation required

	}

CTestScreenInterface::~CTestScreenInterface()

	{

    TearDown();

	}

void CTestScreenInterface::SetupL()

	{

	iUtility = CStreamUtility::NewL();

	iRed.SetInternal(0xFFFF0000);

	iGreen.SetInternal(0xFF00FF00);

	iBlue.SetInternal(0xFF0000FF);

	ReadIniData();

    User::After(KDelay); // consider reading delay from ini file

	}

/**

 * test Suite furniture 

 **/

void CTestScreenInterface::TearDownL()

	{

    // Nothing leaves in this function, 

    // but TearDownL() is needed for the CTestFixture (TEF) interface

    TearDown();

	}

void CTestScreenInterface::TearDown()

    {

    if(iUtility)

        {

        delete iUtility;

        iUtility = NULL;

        }

    }

// Create a suite of all the tests

CTestSuite* CTestScreenInterface::CreateSuiteL(const TDesC& aName)

	{

	SymbianStreamRegisterScreenNotifications(0, 10, KCompositorVersion);

	SUB_SUITE_OPT(CTestScreenInterface,NULL);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0100L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0101L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0102L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0103L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0104L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0105L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0106L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0107L);

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0108L);		

        ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_SCREENINTERFACE_0109L);

        END_SUITE;	

	}

/// This handles any non-member uses of the extended ASSERT_XXX macros

void TefUnitFailLeaveL()

	{

	User::Leave(KErrTEFUnitFail);

	}

void CTestScreenInterface::ReadIniData()

    {

    TBool contiguousFlag;

    TBool returnValue = iConfig.GetBool(KImageSectionName, KContiguousFlag, contiguousFlag);

    if (returnValue)

        {

        if(contiguousFlag)

            {

            iContiguous = EContiguous;

            }

        else

            {

            iContiguous = ENonContiguous;

            }

        }

    TInt fastpathablePixelFormat;

    returnValue = iConfig.GetHex(KImageSectionName, KFastpathablePixelFormat, fastpathablePixelFormat);

    if(returnValue)

        {

        iFastpathablePixelFormat = static_cast<TUidPixelFormat>(fastpathablePixelFormat);

        }

    TInt nonFastpathablePixelFormat;

    returnValue = iConfig.GetHex(KImageSectionName, KNonFastpathablePixelFormat, nonFastpathablePixelFormat);

    if(returnValue)

        {

        iNonFastpathablePixelFormat = static_cast<TUidPixelFormat>(nonFastpathablePixelFormat);

        }

    }

TInt CTestScreenInterface::BaseTestContiguousFlag(TBool aContiguous)

     {

      COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

      CleanupStack::PushL(screenContext);

      TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

      screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                  &screenRotation,

                                  sizeof(screenRotation));

      screenContext->CommitAttribute();

      COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

      screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes, 

                                  sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

      TSurfaceId surface = TSurfaceId::CreateNullId();

      SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight), 

                                                  iFastpathablePixelFormat, attributes.iNormalStride, 

                                                  surface, aContiguous, 1);

      ASSERT_FALSE((*ns).IsNull());

      iUtility->FillStreamL(ns, KRgbGreen);

      TInt err = screenContext->SetTopLayerSurface(ns);

      Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrAll, _L("SetTopLayerSurface() returned %i"),err );

	  RDebug::Printf("SetTopLayerSurface() returned %i",err);

	  if (err==KErrNone)

	      {    //Must successfully SetTopLayerSurface before calling UpdateDisplay. 

          screenContext->UpdateDisplay();

	      }

      CleanupStack::PopAndDestroy(screenContext);

      return err;

     }

/**

@SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0100

@SYMTestCaseDesc		Create a screen size stream and display on screen

@SYMREQ					

@SYMPREQ				REQ 417-54885

@SYMTestType            Unit Test			

@SYMTestPriority        High		

@SYMTestPurpose			Verify a COpenWFC_RI_Display object can be properly created and a stream can be displayed on screen 

@SYMTestActions	        

                        Create a screen context

                        Set display attributes 

                        Create a screen size stream based on the display attributes with contigous and non-contiguous flags

                        Fill the stream

                        Associates the stream with the topmost display layer

                        Update the screen

@SYMTestExpectedResults 

                        If contiguous flag is set in the ini file, and the stream is created using the flag, 

                        the stream should be properly displayed on screen. The stream created using the opposit flag from ini value should fail.

                        If contiguous flag is not set in the ini file, 

                        the stream should be properly displayed on screen for contiguous and non-contiguous flag.

 **/		

void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()

	{

    INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L()"));

    LOG((" *** CTestScreenInterface test 0100L"));

    if(iContiguous != EFlagNotListed)

        {

        // We expect the opposit flag to the one from the ini file to fail

        if(iContiguous == EContiguous)

            {

            ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(ENonContiguous));       

            }

        else

            {

            ASSERT_TRUE(KErrNotSupported == BaseTestContiguousFlag(EContiguous));       

            }

        // The contiguous flag from the ini file should pass

        ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(iContiguous));

        // The last run here should be the "good" run so that it can do a Display() call.

        }

    else

        {

        // Contiguous or Non-contiguous flags should both pass if nothing set in the ini file

        ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(EContiguous));       

        ASSERT_TRUE(KErrNone == BaseTestContiguousFlag(ENonContiguous));           

        }

    INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0100L() done"));

    LOG((" *** CTestScreenInterface test 0100L done"));

	}

/**

@SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0101

@SYMTestCaseDesc		Create a stream, display on screen, then rotate the screen involving scaling

@SYMREQ					

@SYMPREQ				REQ 417-54885

@SYMTestType            Unit Test			

@SYMTestPriority        Medium		

@SYMTestPurpose			Verify screen rotation works  

@SYMTestActions	

                        Create a screen context

                        Set display attributes 

                        Create a screen size stream 

                        Fill the stream

                        Associates the stream with the topmost display layer

                        Update the screen

                        Rotate the screen 90 degrees, 180 degrees, 270 degrees

                        Update the screen respectively

@SYMTestExpectedResults

                        Methods should complete without error.

                        The stream should be properly displayed on screen

 **/

void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()

	{

    INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0101L()"));

    LOG((" *** CTestScreenInterface test 0101L"));

    COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

    CleanupStack::PushL(screenContext);

    COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

    screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes, 

                                sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

    if (attributes.iSupportedRotations > 1)

        {    

        INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);

        TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;

        screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                &screenRotation0,

                                sizeof(screenRotation0));

        screenContext->CommitAttribute();

        TSurfaceId surface = TSurfaceId::CreateNullId();

        SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight), 

                                                iFastpathablePixelFormat, attributes.iNormalStride, 

                                                surface, iContiguous, 1);

        ASSERT_FALSE((*ns).IsNull());

        iUtility->FillStreamL(ns, KRgbRed);

        TInt err = screenContext->SetTopLayerSurface(ns);

        ASSERT_TRUE(err == KErrNone);

        err = screenContext->UpdateDisplay();   

        ASSERT_TRUE(err == KErrNone);

        INFO_PRINTF1(_L("Rotate screen 90 degree"));

        // Rotate screen 90 degree and test

        TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;

        screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                &screenRotation1,

                                sizeof(screenRotation1));

        screenContext->CommitAttribute();

        err = screenContext->UpdateDisplay();   

        ASSERT_TRUE(err == KErrNone);    

        if (attributes.iSupportedRotations > 2)

            {

            INFO_PRINTF1(_L("Rotate screen 180 degree"));

            // Rotate screen 180 degree and test

            TUint32 screenRotation2 = COpenWFC_RI_Display::EScreenRotate180;

            screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                    &screenRotation2,

                                    sizeof(screenRotation2));

            screenContext->CommitAttribute();

            err = screenContext->UpdateDisplay();   

            ASSERT_TRUE(err == KErrNone);

            }

        if (attributes.iSupportedRotations > 3)

            {

            INFO_PRINTF1(_L("Rotate screen 270 degree"));

            // Rotate screen 270 degree and test

            TUint32 screenRotation3 = COpenWFC_RI_Display::EScreenRotate270;

            screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                    &screenRotation3,

                                    sizeof(screenRotation3));

            screenContext->CommitAttribute();

            err = screenContext->UpdateDisplay();   

            ASSERT_TRUE(err == KErrNone);

            }

        // Set screen back to rotation 0 

        screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                    &screenRotation0,

                                    sizeof(screenRotation0));

        screenContext->CommitAttribute();

        err = screenContext->UpdateDisplay();   

        ASSERT_TRUE(err == KErrNone);    

        }

    else

        {

        INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));

        }

    CleanupStack::PopAndDestroy(screenContext);

	}

/**

@SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0102

@SYMTestCaseDesc        Create a stream, display on screen, then rotate the screen, not involving scaling

@SYMREQ                 

@SYMPREQ                REQ 417-54885

@SYMTestType            Unit Test           

@SYMTestPriority        Medium      

@SYMTestPurpose         Verify screen rotation works  

@SYMTestActions 

                        Create a screen context

                        Set display attributes 

                        Create a stream of the size (screenHeight, screenWidth)

                        Fill the stream

                        Associates the stream with the topmost display layer

                        Update the screen

                        Rotate the screen 90 degrees

                        Update the screen

@SYMTestExpectedResults

                        Methods should complete without error.

                        The stream should be properly displayed on screen

 **/		

void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()

	{

    INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0102L()"));

    LOG((" *** CTestScreenInterface test 0102L"));

    COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

    CleanupStack::PushL(screenContext);

    COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

    screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes, 

                                sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

    if (attributes.iSupportedRotations > 1)

        {    

        INFO_PRINTF2(_L("Number of supported rotations: %i "), attributes.iSupportedRotations);

        TUint32 screenRotation0 = COpenWFC_RI_Display::EScreenRotate0;

        screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                &screenRotation0,

                                sizeof(screenRotation0));

        screenContext->CommitAttribute();

        TSurfaceId surface = TSurfaceId::CreateNullId();

        SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalHeight,attributes.iNormalWidth), 

                                                iFastpathablePixelFormat, attributes.iNormalStride, 

                                                surface, iContiguous, 1);

        ASSERT_FALSE((*ns).IsNull());

        iUtility->FillStreamL(ns, KRgbRed);

        TInt err = screenContext->SetTopLayerSurface(ns);

        ASSERT_TRUE(err == KErrNone);

        err = screenContext->UpdateDisplay();   

        ASSERT_TRUE(err == KErrNone);

        INFO_PRINTF1(_L("Rotate screen 90 degree"));

        // Rotate screen 90 degree and test

        TUint32 screenRotation1 = COpenWFC_RI_Display::EScreenRotate90;

        screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                &screenRotation1,

                                sizeof(screenRotation1));

        screenContext->CommitAttribute();

        err = screenContext->UpdateDisplay();   

        ASSERT_TRUE(err == KErrNone);    

        }

    else

        {

        INFO_PRINTF1(_L("Screen rotation is not supported. Test skipped."));

        }

    CleanupStack::PopAndDestroy(screenContext);

	}

/**

@SYMTestCaseID			GRAPHICS_OPENWFC_SCREENINTERFACE_0103

@SYMTestCaseDesc		Create a stream, fill the stream several times and display on screen

@SYMREQ					

@SYMPREQ                REQ 417-54885

@SYMTestType            Unit Test			

@SYMTestPriority        High				

@SYMTestPurpose	        Check displaying stream repeatedly	

@SYMTestActions	

                        Create a screen context

                        Set display attributes 

                        Create a screen size stream 

                        Fill the stream 

                        Associates the stream with the topmost display layer

                        Update the screen

                        Repeat filling the stream, associate with toplayer and update several times

                        Destory the screen context                       

@SYMTestExpectedResults

                        Methods should complete without error.

                        Each time, the stream should be properly displayed on screen

 **/

void CTestScreenInterface::GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()

	{

    INFO_PRINTF1(_L("GRAPHICS_OPENWFC_SCREENINTERFACE_0103L()"));

    LOG((" *** CTestScreenInterface test 0103L"));

    COpenWFC_RI_Display* screenContext = COpenWFC_RI_Display::NewL(KDefaultScreenNumber);

    CleanupStack::PushL(screenContext);

    TUint32 screenRotation = COpenWFC_RI_Display::EScreenRotate0;

    screenContext->SetAttribute(COpenWFC_RI_Display::EScreenAttributeCurrentRotation, 

                                &screenRotation,

                                sizeof(screenRotation));

    screenContext->CommitAttribute();

    COpenWFC_RI_Display::TScreenGeometryAttribute attributes;

    screenContext->GetAttribute(COpenWFC_RI_Display::EScreenAttributeScreenGeometry, &attributes, 

                                sizeof(COpenWFC_RI_Display::TScreenGeometryAttribute));

    TSurfaceId surface = TSurfaceId::CreateNullId();

    SymbianStreamType ns=iUtility->CreateStreamL(TSize(attributes.iNormalWidth,attributes.iNormalHeight), 

                                                iFastpathablePixelFormat, attributes.iNormalStride, 

                                                surface, iContiguous, 1);

    ASSERT_FALSE((*ns).IsNull());

    iUtility->FillStreamL(ns, KRgbYellow);    

    TInt err = screenContext->SetTopLayerSurface(ns);

    ASSERT_TRUE(err == KErrNone);    

    err = screenContext->UpdateDisplay();    

    ASSERT_TRUE(err == KErrNone);

    User::After(KDelay);

    iUtility->FillStreamL(ns, KRgbRed);    

    err = screenContext->SetTopLayerSurface(ns);

    ASSERT_TRUE(err == KErrNone);    

    err = screenContext->UpdateDisplay();    

    ASSERT_TRUE(err == KErrNone);

    User::After(KDelay);

    iUtility->FillStreamL(ns, KRgbGreen);    

    err = screenContext->SetTopLayerSurface(ns);

    ASSERT_TRUE(err == KErrNone);    

    err = screenContext->UpdateDisplay();    

    ASSERT_TRUE(err == KErrNone);

    User::After(KDelay);

    iUtility->FillStreamL(ns, KRgbYellow);    

    err = screenContext->SetTopLayerSurface(ns);

    ASSERT_TRUE(err == KErrNone);    

    err = screenContext->UpdateDisplay();    

    ASSERT_TRUE(err == KErrNone);

    User::After(KDelay);

    iUtility->FillStreamL(ns, KRgbRed);    

    err = screenContext->SetTopLayerSurface(ns);

    ASSERT_TRUE(err == KErrNone);    

    err = screenContext->UpdateDisplay();    

    ASSERT_TRUE(err == KErrNone);

    User::After(KDelay);

    // Set a non-topmost layer

    err = screenContext->SetLayerSurface(1, ns);

    ASSERT_TRUE(err == KErrArgument);    

    CleanupStack::PopAndDestroy(screenContext);    

	}

/**

@SYMTestCaseID          GRAPHICS_OPENWFC_SCREENINTERFACE_0104

@SYMTestCaseDesc        Display all display attributes

@SYMREQ                 

@SYMPREQ                REQ 417-54885

@SYMTestType            Unit Test

@SYMTestPriority        High

@SYMTestPurpose         Check display attributes 

@SYMTestActions 

                        Create a screen context

                        Set display attributes