Symaptic: os/graphics/windowing/windowserver/test/tauto/tdevicerotation.cpp@260cb5ec6c19

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Set of tests for Tracing Device Rotation. These tests generally test

    15 // RWsSession::IndicateAppOrientation(...).

    16 //

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Nokia test code

    22 */

    24 #include "tdevicerotation.h"

    25 #include "themeserverpropertydefine.h"

    26 #include "..\..\nga\server\renderorientationtracker.h"

    27 #include <hal.h>

    28 #include <hal_data.h>

    29 #include <w32std.h>

    31 const TInt KPublishTimeout = 1000000; // 1 second in microseconds

    33 //

    34 // CTDeviceRotation Definition

    35 //

    37 CTDeviceRotation::CTDeviceRotation(CTestStep* aStep):

    38 	CTGraphicsBase(aStep), iWaitForPublishOnNextTest(ETrue)

    39 	{

    40 	}

    42 CTDeviceRotation::~CTDeviceRotation()

    43 	{

    44     iPublishTimer.Close();

    46     iChildWindow.Close();

    47     iWindowGroup.Close();

    48     iWs.Close();

    50     iSecondChildWindow.Close();

    51     iSecondWindowGroup.Close();

    52     iSecondWs.Close();

    54     /* This Process called with the argument KThemeServerPropertyDefineCmdDelete, deletes

    55        the theme server RProperty. This is because an RProperty can only be defined and

    56        deleted from within a process with the same UID3 as the RProperty catogory you are

    57        trying to define/delete.*/

    58     RProcess themeServerPropertyDefine;

    59     TInt err = themeServerPropertyDefine.Create(KThemeServerPropertyDefine,

    60             KThemeServerPropertyDefineCmdDelete);

    61     if (KErrNone != err)

    62         {

    63         _LIT(KLog, "themeServerPropertyDefine.Create() failed with error: %d");

    64         INFO_PRINTF2(KLog, err);

    65         TEST(EFalse);

    66         }

    67     //wait for themeServerPropertyDefine process to terminate

    68     TRequestStatus themeServerPropertyDefineLogonStatus;

    69     themeServerPropertyDefine.Logon(themeServerPropertyDefineLogonStatus);

    70     themeServerPropertyDefine.Resume();

    71     User::WaitForRequest(themeServerPropertyDefineLogonStatus);

    72     if (themeServerPropertyDefineLogonStatus != KErrNone)

    73         {

    74         _LIT(KLog, "themeServerPropertyDefine.Logon() failed with error: %d");

    75         INFO_PRINTF2(KLog, themeServerPropertyDefineLogonStatus);

    76         TEST(EFalse);

    77         }

    78     themeServerPropertyDefine.Close();

    80     iRenderOrientationProperty.Delete(KRenderOrientationCategory, KRenderOrientationKey);

    81     iRenderOrientationProperty.Close();

    82     iThemeServerOrientationProperty.Close();

    83     }

    85 void CTDeviceRotation::ConstructL()

    86     {

    87     TInt err = iWs.Connect();

    88     TESTL(err == KErrNone);

    90     err = iSecondWs.Connect();

    91     TESTL(KErrNone == err);

    93     iWs.SetAutoFlush(ETrue);

    94     iSecondWs.SetAutoFlush(ETrue);

    96     iWindowGroup = RWindowGroup(iWs);

    97     err = iWindowGroup.Construct(iWs.Handle());

    98     TESTL(KErrNone == err);

    99     iWindowGroup.SetOrdinalPosition(0,1);

   101     iChildWindow = RWindow(iWs);

   102     err = iChildWindow.Construct(iWindowGroup, reinterpret_cast<TUint32>(&iChildWindow));

   103     TESTL(KErrNone == err);

   105     iSecondWindowGroup = RWindowGroup(iSecondWs);

   106     err = iSecondWindowGroup.Construct(iSecondWs.Handle());

   107     TESTL(KErrNone == err);

   108     iSecondWindowGroup.SetOrdinalPosition(1,1);

   110     iSecondChildWindow = RWindow(iSecondWs);

   111     err = iSecondChildWindow.Construct(iSecondWindowGroup, reinterpret_cast<TUint32>(&iSecondChildWindow));

   112     TESTL(KErrNone == err);

   114     err= iRenderOrientationProperty.Attach(KRenderOrientationCategory, KRenderOrientationKey, EOwnerThread);

   115     TESTL(KErrNone == err);

   116     iRenderOrientationProperty.Subscribe(iRenderOrientationStatus);

   118     /* This Process called with the argument KThemeServerPropertyDefineCmdDefine, defines

   119        the theme server catagory to be the same as the theme servers process ID. This is

   120        because an RProperty can only be defined and deleted from within a process with the

   121        same UID3 as the RProperty catogory you are trying to define/delete.*/

   122     RProcess themeServerPropertyDefine;

   123     err = themeServerPropertyDefine.Create(KThemeServerPropertyDefine,KThemeServerPropertyDefineCmdDefine);

   124     TESTL(KErrNone == err);

   125     TRequestStatus themeServerPropertyDefineLogonStatus;

   126     themeServerPropertyDefine.Logon(themeServerPropertyDefineLogonStatus);

   127     themeServerPropertyDefine.Resume();

   128     User::WaitForRequest(themeServerPropertyDefineLogonStatus);

   129     TESTL(KErrNone == themeServerPropertyDefineLogonStatus.Int());

   130     themeServerPropertyDefine.Close();

   132     err = iThemeServerOrientationProperty.Attach(KThemeOrientationCategory, KThemeOrientationKey, EOwnerThread);

   133     TESTL(KErrNone == err);

   135     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   137     iPublishTimer.CreateLocal();

   138     }

   140 void CTDeviceRotation::SimulateThemeServerOrientation(TRenderOrientation aOrientation)

   141     {

   142     _LIT(KFunctionInfo, "SimulateThemeServerOrientation(aOrientation = %d)");

   143     INFO_PRINTF2(KFunctionInfo, aOrientation);

   144     TInt err = iThemeServerOrientationProperty.Set(aOrientation);

   145     if (KErrNone != err)

   146         {

   147         _LIT(KLog,"iThemeServerOrientationProperty.Set(%d) failed with err %d");

   148         INFO_PRINTF3(KLog,aOrientation,err);

   149         TEST(EFalse);

   150         }

   151     switch(aOrientation)

   152         {

   153         case EDisplayOrientationNormal:

   154         case EDisplayOrientation90CW:

   155         case EDisplayOrientation180:

   156         case EDisplayOrientation270CW:

   157             {

   158             if(KErrNone == err)

   159                 {

   160                 iCurrentThemeServerOrientation = aOrientation;

   161                 }

   162             break;

   163             }

   164         default:

   165             _LIT(KLog, "This orientation is not supported by theme server.");

   166         	INFO_PRINTF1(KLog);

   167         }

   168     }

   170 void CTDeviceRotation::IsOrientationCorrect(TRenderOrientation aExpectedOrientation)

   171     {

   172     // timer to timeout when nothing is published

   173     iPublishTimer.After(iPublishTimerStatus, KPublishTimeout);

   175     // wait for either

   176     User::WaitForRequest(iRenderOrientationStatus, iPublishTimerStatus);

   178     // check that the orientation was published or not, as expected

   179     if(iWaitForPublishOnNextTest)

   180         {

   181         // Check that it really has published

   182         if(iRenderOrientationStatus.Int()==KErrNone && iPublishTimerStatus.Int()==KRequestPending)

   183             {

   184             iPublishTimer.Cancel();

   185             // re-subscribe

   186             iRenderOrientationProperty.Subscribe(iRenderOrientationStatus);

   187             }

   188         else

   189             {

   190             _LIT(KLog,"Timed out (%d) while waiting for render orientation %d to be published");

   191             INFO_PRINTF3(KLog,iRenderOrientationStatus.Int(),aExpectedOrientation);

   192             TEST(EFalse);

   193             }

   194         }

   195     else

   196         {

   197         // Check that it really hasn't published

   198         if(iRenderOrientationStatus.Int()!=KRequestPending)

   199             {

   200             _LIT(KLog,"Render Orientation %d was published (%d) when not expected (timeout = %d)");

   201             INFO_PRINTF4(KLog,aExpectedOrientation, iRenderOrientationStatus.Int(),iPublishTimerStatus.Int());

   202             iPublishTimer.Cancel();

   203             TEST(EFalse);

   204             }

   205         else if(iPublishTimerStatus.Int()!=KErrNone)

   206             {

   207             _LIT(KLog,"Timeout failure %d");

   208             INFO_PRINTF2(KLog,iPublishTimerStatus.Int());

   209             TEST(EFalse);

   210             }

   212         // reset to default

   213         iWaitForPublishOnNextTest = ETrue;

   214         }

   216     // Retrieve the value.

   217     TInt orientation;

   218     TInt err = iRenderOrientationProperty.Get(orientation);

   219     if(KErrNone != err)

   220            {

   221            _LIT(KLog,"iThemeServerOrientationProperty.Get(...) failed with err %d");

   222            INFO_PRINTF2(KLog,err);

   223            TEST(EFalse);

   224            }

   225     else if(aExpectedOrientation == EDisplayOrientationAuto)

   226         {

   227         TEST(orientation == iCurrentThemeServerOrientation);

   228         CheckHalSetting(iCurrentThemeServerOrientation);

   229         }

   230     else

   231         {

   232         TEST(orientation == aExpectedOrientation);

   233         CheckHalSetting(static_cast<TRenderOrientation>(orientation));

   234         }

   235     }

   237 void CTDeviceRotation::CheckHalSetting(TRenderOrientation aOrientation)

   238     {

   239     HALData::TDigitiserOrientation halOrientationExp = static_cast<HALData::TDigitiserOrientation>

   240             (HALData::EDigitiserOrientation_000 + (aOrientation - EDisplayOrientationNormal));

   241     TInt halOrientation;

   242     TInt err = HAL::Get(iWs.GetFocusScreen(), HALData::EDigitiserOrientation, halOrientation);

   243     if (err != KErrNotSupported)

   244         {

   245         if (err != KErrNone)

   246             {

   247             _LIT(KLog,"Getting HAL orientation attribute returned error %d when no error expected");

   248             INFO_PRINTF2(KLog,err);

   249             }

   250         TEST(err==KErrNone);

   251         if (halOrientationExp != halOrientation)

   252             {

   253             _LIT(KLog,"HAL orientation is %d when expected to be %d");

   254             INFO_PRINTF3(KLog, halOrientation, halOrientationExp);

   255             }

   256         TEST(halOrientationExp==halOrientation);

   257         }

   258     else

   259         {

   260         _LIT(KLog,"HAL-Orientation HALData::EDigitiserOrientation isn't supported by Driver");

   261         INFO_PRINTF1(KLog);

   262         }

   263     }

   265 void CTDeviceRotation::TestIndicateAppOrientation(TRenderOrientation aOrientation)

   266 	{

   267     _LIT(KTestInfo, "TestIndicateAppOrientation(aOrientation = %d)");

   268     INFO_PRINTF2(KTestInfo, aOrientation);

   269 	if (EDisplayOrientationIgnore == aOrientation)

   270 	    {

   271         TEST(EFalse);

   272         _LIT(KLog, "TestIndicateAppOrientation(TRenderOrientation aOrientation) cannot be used with EDisplayOrientationIgnore");

   273         INFO_PRINTF1(KLog);

   274 	    }

   275 	iWs.IndicateAppOrientation(aOrientation);

   276 	iWindowGroup.SetOrdinalPosition(0);

   277 	IsOrientationCorrect(aOrientation);

   278 	}

   280 void CTDeviceRotation::TestIndicateAppOrientation(TRenderOrientation aOrientation, TRenderOrientation aSecondOrientation)

   281     {

   282     _LIT(KTestInfo, "TestIndicateAppOrientation(aOrientation = %d, aSecondOrientation = %d)");

   283     INFO_PRINTF3(KTestInfo, aOrientation, aSecondOrientation);

   284     //Inform window serve the orientation status

   285     iWs.IndicateAppOrientation(aOrientation);

   286     iSecondWs.IndicateAppOrientation(aSecondOrientation);

   288     iWindowGroup.SetOrdinalPosition(0,1);

   289     iSecondWindowGroup.SetOrdinalPosition(1,1);

   291     if(aOrientation != EDisplayOrientationIgnore)

   292         {

   293         IsOrientationCorrect(aOrientation);

   294         }

   295     else

   296         {

   297         IsOrientationCorrect(aSecondOrientation);

   298         }

   299     }

   301 void CTDeviceRotation::TestAppOrientationOnSwap(TRenderOrientation aOrientation, TRenderOrientation aSecondOrientation)

   302     {

   303     _LIT(KTestInfo, "TestAppOrientationOnSwap(aOrientation = %d, aSecondOrientation = %d)");

   304     INFO_PRINTF3(KTestInfo, aOrientation, aSecondOrientation);

   306     iWs.IndicateAppOrientation(aOrientation);

   307     iSecondWs.IndicateAppOrientation(aSecondOrientation);

   309     iSecondWindowGroup.SetOrdinalPosition(0);

   310     if (aSecondOrientation != EDisplayOrientationIgnore)

   311         {

   312         IsOrientationCorrect(aSecondOrientation);

   313         }

   314     else

   315         {

   316         IsOrientationCorrect(aOrientation);

   317         }

   318     }

   320 void CTDeviceRotation::RunTestCaseL(TInt aCurTestCase)

   321 	{

   322     _LIT(KNewLine, "\n");

   323     (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KUnknownSYMTestCaseIDName);

   324 	switch(aCurTestCase)

   325 		{

   326 	    case 1:

   327             _LIT(KTestStepID1,"Test Initial Orientations");

   328             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID1);

   329             INFO_PRINTF1(KNewLine);

   330             INFO_PRINTF1(KTestStepID1);

   331             TestInitialOrientation();

   332             break;

   333 		case 2:

   334     	    _LIT(KTestStepID2,"Test Fixed Orientations");

   335             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID2);

   336             INFO_PRINTF1(KNewLine);

   337             INFO_PRINTF1(KTestStepID2);

   338             TestFixedOrientations();

   339 			break;

   340 		case 3:

   341     	    _LIT(KTestStepID3,"Test Auto Orientation");

   342 		    (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID3);

   343 		    INFO_PRINTF1(KNewLine);

   344 		    INFO_PRINTF1(KTestStepID3);

   345 		    TestAutoOrientation();

   346 			break;

   347 		case 4:

   348             _LIT(KTestStepID4,"Test Ignore Orientation");

   349             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID4);

   350             INFO_PRINTF1(KNewLine);

   351             INFO_PRINTF1(KTestStepID4);

   352             TestIgnoreOrientation();

   353 			break;

   354         case 5:

   355             _LIT(KTestStepID5,"Test Swap Orientations");

   356             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID5);

   357             INFO_PRINTF1(KNewLine);

   358             INFO_PRINTF1(KTestStepID5);

   359             TestFixedOrientationsOnWindowSwap();

   360 			break;

   361         case 6:

   362             _LIT(KTestStepID6,"Test Auto Swap Orientations");

   363             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID6);

   364             INFO_PRINTF1(KNewLine);

   365             INFO_PRINTF1(KTestStepID6);

   366             TestAutoOrientationOnWindowSwap();

   367             break;

   368         case 7:

   369             _LIT(KTestStepID7,"Test Ignore Swap Orientations");

   370             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID7);

   371             INFO_PRINTF1(KNewLine);

   372             INFO_PRINTF1(KTestStepID7);

   373             TestIgnoreOrientationOnWindowSwap();

   374 			break;

   375         case 8:

   376             _LIT(KTestStepID8,"Test Auto Swap Orientations");

   377             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID8);

   378             INFO_PRINTF1(KNewLine);

   379             INFO_PRINTF1(KTestStepID8);

   380             TestIgnoreAutoOrientationOnWindowSwap();

   381             break;

   382         case 9:

   383             _LIT(KTestStepID9,"Test Invalid App Orientations");

   384             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID9);

   385             INFO_PRINTF1(KNewLine);

   386             INFO_PRINTF1(KTestStepID9);

   387             TestInvalidAppOrientation();

   388             break;

   389         case 10:

   390             _LIT(KTestStepID10,"Test Invalid Theme Server Orientations");

   391             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KTestStepID10);

   392             INFO_PRINTF1(KNewLine);

   393             INFO_PRINTF1(KTestStepID10);

   394             TestInvalidThemeServerOrientation();

   395             break;

   396 		default:

   397             (reinterpret_cast<CTDeviceRotationStep*>(iStep))->SetTestStepID(KNotATestSYMTestCaseIDName);

   398 			(reinterpret_cast<CTDeviceRotationStep*>(iStep))->CloseTMSGraphicsStep();

   399 			TestComplete();

   400 		}

   401 	(reinterpret_cast<CTDeviceRotationStep*>(iStep))->RecordTestResultL();

   402 	}

   405 /**

   406  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0001

   407  @SYMTestCaseDesc           Test Auto Orientation

   408  @SYMPREQ                   460936 Tracking Device Rotation

   409  @SYMTestPriority           1

   410  @SYMTestPurpose            To test that we can return the correct initial orientation value from

   411                             the windwoserver.

   412  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   413                             windowserver orientation changes.

   414                             We have set up an RWindowGroup at the foreground and not altered its

   415                             indicated orientation.

   416  @SYMTestActions            1) Get the value of the orientation as published by window server.

   418  @SYMTestExpectedResults    The windowserver should return EDisplayOrientationNormal

   419  */

   420 void CTDeviceRotation::TestInitialOrientation()

   421     {

   422     iWaitForPublishOnNextTest = EFalse;

   423     IsOrientationCorrect(EDisplayOrientationNormal);

   424     }

   426 /**

   427  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0002

   428  @SYMTestCaseDesc           Test Fixed Orientations

   429  @SYMPREQ                   460936 Tracking Device Rotation

   430  @SYMTestPriority           1

   431  @SYMTestPurpose            To test that we can return the correct orientation value from

   432                             the windwoserver after we indicate the application orientation

   433                             as fixed values using RWsSession::IndicateAppOrientation. Any

   434                             theme server orientations should be ignored.

   435  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   436                             windowserver orientation changes.

   437                             An RProperty is set up to publish Theme server Orientation changes.

   438                             We have set up an RWindowGroup in the foreground.

   439                             Windowserver orientation currently set to EDisplayOrientationNormal.

   441  @SYMTestActions            1) Set Theme Server orientation to EDisplayOrientation90CW.

   442                             2) Set the RWindowgroup in ordinal position 0 to a fixed orientation.

   443                             3) Check the published orinetation value in windowserver.

   444                             4) Repeat steps 2) and 3) for all fixed orientations

   445                             3) Set Theme Server orientation to EDisplayOrientationNormal.

   446                             4) Repeat Steps 2-4).

   448  @SYMTestExpectedResults    The orientation set in step 2) should always be the same as the

   449                             orientation set in step 2)

   450  */

   451 void CTDeviceRotation::TestFixedOrientations()

   452     {

   453     iWaitForPublishOnNextTest = EFalse;

   454     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   455     TestIndicateAppOrientation(EDisplayOrientationNormal);

   456     TestIndicateAppOrientation(EDisplayOrientation90CW);

   457     TestIndicateAppOrientation(EDisplayOrientation180);

   458     TestIndicateAppOrientation(EDisplayOrientation270CW);

   460     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   461     TestIndicateAppOrientation(EDisplayOrientationNormal);

   462     TestIndicateAppOrientation(EDisplayOrientation90CW);

   463     TestIndicateAppOrientation(EDisplayOrientation180);

   464     TestIndicateAppOrientation(EDisplayOrientation270CW);

   466     SimulateThemeServerOrientation(EDisplayOrientation180);

   467     TestIndicateAppOrientation(EDisplayOrientationNormal);

   468     TestIndicateAppOrientation(EDisplayOrientation90CW);

   469     TestIndicateAppOrientation(EDisplayOrientation180);

   470     TestIndicateAppOrientation(EDisplayOrientation270CW);

   472     SimulateThemeServerOrientation(EDisplayOrientation270CW);

   473     TestIndicateAppOrientation(EDisplayOrientationNormal);

   474     TestIndicateAppOrientation(EDisplayOrientation90CW);

   475     TestIndicateAppOrientation(EDisplayOrientation180);

   476     TestIndicateAppOrientation(EDisplayOrientation270CW);

   477     }

   479 /**

   480  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0003

   481  @SYMTestCaseDesc           Test Auto Orientation

   482  @SYMPREQ                   460936 Tracking Device Rotation

   483  @SYMTestPriority           1

   484  @SYMTestPurpose            To test that we can return the correct orientation value from

   485                             the windwoserver after we indicate the application orientation

   486                             as auto values using RWsSession::IndicateAppOrientation. The wserv

   487                             should publish the theme server orientation changes only.

   488  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   489                             windowserver orientation changes.

   490                             An RProperty is set up to publish Theme server Orientation changes.

   491                             We have set up an RWindowGroup in the foreground.

   492                             WindowServer orinetation is not set to EDisplayOrientation90CW.

   494  @SYMTestActions            1) Set Theme Server orientation to EDisplayOrientation90CW.

   495                             2) Set the RWindowgroup in ordinal position 0 to auto orientation.

   496                             3) Check the published orinetation value in windowserver.

   497                             4) Set Theme Server orientation to EDisplayOrientationNormal.

   498                             5) Check the value of the orientation as published by window server.

   499                             6) Repeat 4) and 5) for EDisplayOrientation180 and

   500                                EDisplayOrientation270CW

   501                             7) repeat 4) and 5) again for EDisplayOrientation270CW

   503  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   504                             The orientation checked in step 3) should be the theme server

   505                             orientation set in step 1).

   506                             The orientations checked in step 5) should be the theme server

   507                             orientations set in step 4).

   508                             We should recieve no notification for step 7).

   509  */

   510 void CTDeviceRotation::TestAutoOrientation()

   511     {

   512     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   513     TestIndicateAppOrientation(EDisplayOrientationAuto);

   514     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   515     IsOrientationCorrect(iCurrentThemeServerOrientation);

   516     // Now flip it upside down to ensure that nothing assumes this will only be updated incrementally

   517     SimulateThemeServerOrientation(EDisplayOrientation180);

   518     IsOrientationCorrect(iCurrentThemeServerOrientation);

   519     SimulateThemeServerOrientation(EDisplayOrientation270CW);

   520     IsOrientationCorrect(iCurrentThemeServerOrientation);

   522     // And check that wserv doesn't publish if the theme server publishes the existing orientation

   523     SimulateThemeServerOrientation(EDisplayOrientation270CW);

   524     iWaitForPublishOnNextTest = EFalse;

   525     IsOrientationCorrect(iCurrentThemeServerOrientation);

   526     }

   528 /**

   529  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0004

   530  @SYMTestCaseDesc           Test Ignore Orientation

   531  @SYMPREQ                   460936 Tracking Device Rotation

   532  @SYMTestPriority           1

   533  @SYMTestPurpose            To test that we can return the correct orientation value from

   534                             the windwoserver after we indicate the front applications

   535                             orientation as ignore.

   536  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   537                             windowserver orientation changes.

   538                             An RProperty is set up to publish Theme server Orientation changes.

   539                             We have set up two RWindowGroups in the ordinal positions 0 and 1.

   540                             WindowServer orinetation is not set to EDisplayOrientationNormal.

   542  @SYMTestActions            1) Set Theme Server orientation to EDisplayOrientation90CW.

   543                             2) Set the RWindowGroup in ordinal position 0 to a ignore orientation.

   544                             3) Set the RWindowgroup in ordinal position 1 to a fixed orientation.

   545                             4) Check the published orinetation value in windowserver.

   546                             5) Repeat steps 2-4) varying the fixed orientation set in step 2).

   547                             6) Set Theme Server orientation to EDisplayOrientation90CW.

   548                             7) Set the RWindowGroup in ordinal position 0 to a ignore orientation.

   549                             8) Set the RWindowgroup in ordinal position 1 to a fixed orientation.

   550                             9) Check the published orinetation value in windowserver.

   551                             10) Set Theme Server orientation to EDisplayOrientationNormal.

   552                             11) Check the published orinetation value in windowserver.

   554  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   555                             All orientations checked in step 4) should be the fixed orientations

   556                             of the windows in ordinal position 1, as set in step 3).

   557                             The orientation checked in step 9) should be the theme server

   558                             orientation set in step 6).

   559                             The orientation checked in step 11) should be the theme server

   560                             orientation set in step 10).

   561  */

   562 void CTDeviceRotation::TestIgnoreOrientation()

   563     {

   564     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   565     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientationNormal);

   566     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientation90CW);

   567     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientation180);

   568     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientation270CW);

   570     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   571     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientationAuto);

   572     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   573     IsOrientationCorrect(iCurrentThemeServerOrientation);

   574     }

   576 /**

   577  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0005

   578  @SYMTestCaseDesc           Test Fixed Orientations On Swap

   579  @SYMPREQ                   460936 Tracking Device Rotation

   580  @SYMTestPriority           1

   581  @SYMTestPurpose            To test that we get notifactation of a change in orientation and can

   582                             return the correct orientation value from the windwoserver after we

   583                             swap windows with varying fixed orienations.

   584  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   585                             windowserver orientation changes.

   586                             We have set up two RWindowGroups in the ordinal positions 0 and 1.

   588  @SYMTestActions            1) Set the RWindowGroup in ordinal position 0 to a fixed orientation.

   589                             2) Set the RWindowgroup in ordinal position 1 to a fixed orientation.

   590                             3) Check the published orinetation value in windowserver.

   591                             4) Move the RWindowGroup ordinal position 1 to the ordinal position 0.

   592                             5) Check the published orinetation value in windowserver.

   593                             6) Repeat steps 1-5 but vary the values the fixed orientation of the

   594                                RWindows set in steps 1) and 2)

   596  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   597                             All orientations checked in step 3) should be the fixed orientations

   598                             of the windows in ordinal position 0, as set in step 1).

   599                             The orientations checked in step 5) should be the fixed orientations

   600                             of the windows which was in ordinal position 1 before each swap, as

   601                             set in step 2).

   602  */

   603 void CTDeviceRotation::TestFixedOrientationsOnWindowSwap()

   604     {

   605     iWaitForPublishOnNextTest = EFalse;

   606     TestIndicateAppOrientation(EDisplayOrientationNormal, EDisplayOrientationNormal);

   607     iWaitForPublishOnNextTest = EFalse;

   608     TestAppOrientationOnSwap(EDisplayOrientationNormal, EDisplayOrientationNormal);

   609     TestIndicateAppOrientation(EDisplayOrientationNormal, EDisplayOrientation90CW);

   610     TestAppOrientationOnSwap(EDisplayOrientationNormal, EDisplayOrientation90CW);

   611     TestIndicateAppOrientation(EDisplayOrientation90CW, EDisplayOrientationNormal);

   612     TestAppOrientationOnSwap(EDisplayOrientation90CW, EDisplayOrientationNormal);

   613     }

   615 /**

   616  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0006

   617  @SYMTestCaseDesc           Test Auto Orientations On Swap

   618  @SYMPREQ                   460936 Tracking Device Rotation

   619  @SYMTestPriority           1

   620  @SYMTestPurpose            To test that we get notifactation of a change in orientation and can

   621                             return the correct orientation value from the windwoserver after we

   622                             swap windows with auto orienations.

   623  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   624                             windowserver orientation changes.

   625                             An RProperty is set up to publish Theme server Orientation changes.

   626                             We have set up two RWindowGroups in the ordinal positions 0 and 1.

   627                             WindowServer orinetation is not set to EDisplayOrientation270CW.

   629  @SYMTestActions            1) Set the theme server orientation.

   630                             2) Set the RWindowGroup in ordinal position 0 to a fixed orientation.

   631                             3) Set the RWindowGroup in ordinal position 1 to auto orientation.

   632                             4) Check the published orinetation value in windowserver.

   633                             5) Move the RWindowGroup ordinal position 1 to the ordinal position 0.

   634                             6) Check the published orinetation value in windowserver.

   635                             7) Repeat steps 1-6 but vary the values of the theme server

   636                                orientation in step 1) and the fixed orientation of the frontwindow

   637                                in 2)

   638  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   639                             All orientations checked in step 4) should be the fixed orientations

   640                             of the front windows, which have been set in step 2).

   641                             All orientations checked in step 6) should be the theme server

   642                             orientations set in step 1)

   643  */

   644 void CTDeviceRotation::TestAutoOrientationOnWindowSwap()

   645     {

   646     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   647     TestIndicateAppOrientation(EDisplayOrientation270CW, EDisplayOrientationAuto);

   648     TestAppOrientationOnSwap(EDisplayOrientation270CW, EDisplayOrientationAuto);

   649     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   650     TestIndicateAppOrientation(EDisplayOrientationAuto, EDisplayOrientation180);

   651     TestAppOrientationOnSwap(EDisplayOrientationAuto, EDisplayOrientation180);

   653     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   654     TestIndicateAppOrientation(EDisplayOrientation90CW, EDisplayOrientationAuto);

   655     iWaitForPublishOnNextTest = EFalse;

   656     TestAppOrientationOnSwap(EDisplayOrientation90CW, EDisplayOrientationAuto);

   657     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   658     TestIndicateAppOrientation(EDisplayOrientationAuto, EDisplayOrientationNormal);

   659     iWaitForPublishOnNextTest = EFalse;

   660     TestAppOrientationOnSwap(EDisplayOrientationAuto, EDisplayOrientationNormal);

   661     }

   663 /**

   664  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0007

   665  @SYMTestCaseDesc           Test Swap Orientations with Ignore Orientation

   666  @SYMPREQ                   460936 Tracking Device Rotation

   667  @SYMTestPriority           1

   668  @SYMTestPurpose            To test that we get notifactation of a change in orientation and can

   669                             return the correct orientation value from the windwoserver after we

   670                             swap windows with ignore orienations.

   671  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   672                             windowserver orientation changes.

   673                             An RProperty is set up to publish Theme server Orientation changes.

   674                             We have set up two RWindowGroups in the ordinal positions 0 and 1.

   676  @SYMTestActions            1) Set the theme server orientation.

   677                             2) Set the RWindowGroup in ordinal position 0 to ignore orientation.

   678                             3) Set the RWindowGroup in ordinal position 1 to a fixed orientation.

   679                             4) Check the published orinetation value in windowserver.

   680                             5) Move the RWindowGroup ordinal position 1 to the ordinal position 0.

   681                             6) Check the published orinetation value in windowserver.

   682                             7) Repeat steps 1-6 but vary the values of the theme server

   683                                orientation in step 1) and the fixed orientation of the frontwindow

   684                                in 3)

   685                             8) Set the theme server orientation.

   686                             9) Set the RWindowGroup in ordinal position 0 to a fixedorientation.

   687                             10) Set the RWindowGroup in ordinal position 1 to ignore orienation.

   688                             11) Repeat steps 4-6)

   689                             12) Repeat steps 8-11) but vary the values of the theme server

   690                                orientation in step 8) and the fixed orientation of the

   691                                RwindowGroup in 9)

   693  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   694                             All orientations checked in step 4) and 6) should be the fixed

   695                             orientations RWindowGroups which have been set in step 3).

   696                             All orientations checked in step 11) should be the fixed orientations

   697                             of the front RWindowGroups which have been set in step 9).

   698 */

   699 void CTDeviceRotation::TestIgnoreOrientationOnWindowSwap()

   700     {

   701     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   702     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientation270CW);

   703     TestAppOrientationOnSwap(EDisplayOrientationIgnore, EDisplayOrientation180);

   705     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   706     TestIndicateAppOrientation(EDisplayOrientationIgnore, EDisplayOrientationNormal);

   707     TestAppOrientationOnSwap(EDisplayOrientationIgnore, EDisplayOrientation90CW);

   709     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   710     TestIndicateAppOrientation(EDisplayOrientation270CW, EDisplayOrientationIgnore);

   711     TestAppOrientationOnSwap(EDisplayOrientation180, EDisplayOrientationIgnore);

   713     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   714     TestIndicateAppOrientation(EDisplayOrientationNormal, EDisplayOrientationIgnore);

   715     TestAppOrientationOnSwap(EDisplayOrientation90CW, EDisplayOrientationIgnore);

   716     }

   718 /**

   719  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0008

   720  @SYMTestCaseDesc           Test Swap Orientations with Auto and Ignore Orientations

   721  @SYMPREQ                   460936 Tracking Device Rotation

   722  @SYMTestPriority           1

   723  @SYMTestPurpose            To test that we get notifactation of a change in orientation and can

   724                             return the correct orientation value from the windwoserver after we

   725                             swap windows with auto and ignore orienations.

   726  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   727                             windowserver orientation changes.

   728                             An RProperty is set up to publish Theme server Orientation changes.

   729                             We have set up two RWindowGroups in the ordinal positions 0 and 1.

   730  @SYMTestActions            1) Set the theme server orientation to EDisplayOrientationNormal.

   731                             2) Set the RWindowGroup in ordinal position 0 to auto orientation.

   732                             3) Set the RWindowGroup in ordinal position 1 to ignore orientation.

   733                             4) Check the published orinetation value in windowserver.

   734                             5) Set the theme server orientation to EDisplayOrientation90CW.

   735                             6) Check the published orinetation value in windowserver.

   736                             7) Set the theme server orientation to EDisplayOrientationNormal.

   737                             8) Move the RWindowGroup in ordinal position 1 to ordinal position 0.

   738                             9) Check the published orinetation value in windowserver.

   739                             10) Set the theme server orientation to EDisplayOrientation90CW.

   740                             11) Check the published orinetation value in windowserver.

   742  @SYMTestExpectedResults    We should get expected notifications where orientations have changed.

   743                             The orientations checked in step 4), 6), 9) and  11) should all be

   744                             the orientations set to the themeserver in steps 1), 5), 8) and 10)

   745                             respecvtively.

   746 */

   747 void CTDeviceRotation::TestIgnoreAutoOrientationOnWindowSwap()

   748     {

   749     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   750     TestIndicateAppOrientation(EDisplayOrientationAuto, EDisplayOrientationIgnore);

   751     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   752     IsOrientationCorrect(iCurrentThemeServerOrientation);

   754     SimulateThemeServerOrientation(EDisplayOrientationNormal);

   755     iSecondWindowGroup.SetOrdinalPosition(0);

   756     IsOrientationCorrect(iCurrentThemeServerOrientation);

   757     SimulateThemeServerOrientation(EDisplayOrientation90CW);

   758     IsOrientationCorrect(iCurrentThemeServerOrientation);

   759     }

   761 /**

   762  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0009

   763  @SYMTestCaseDesc           Test Invalid App Orientation

   764  @SYMPREQ                   ###TrackingDeviceRotation### TODO replace me

   765  @SYMTestPriority           1

   766  @SYMTestPurpose            To test that an invalid orientation is ignored.

   767  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   768                             windowserver orientation changes.

   769                             An RProperty is set up to publish Theme server Orientation changes.

   770                             We have set up an RWindowGroup in ordinal position 0.

   771  @SYMTestActions            1) Set the theme server orientation to EDisplayOrientationNormal.

   772                             2) Set the RWindowGroup in ordinal position 0 to

   773                                EDisplayOrientation90CW.

   774                             4) Check the published orinetation value in windowserver.

   775                             5) Set the RWindowGroup in ordinal position 0 to an invalid

   776                                orientation.

   777                             6) Check the published orinetation value in windowserver.

   779  @SYMTestExpectedResults    Wserv should publish an orientation change for 2) but not for 5).

   780                             The orientations checked in steps 4) and 6) should both be the

   781                             orientation set in step 2).

   782 */

   783 void CTDeviceRotation::TestInvalidAppOrientation()

   784 	{

   785 	SimulateThemeServerOrientation(EDisplayOrientationNormal);

   786 	TestIndicateAppOrientation(EDisplayOrientation90CW);

   787 	iWs.IndicateAppOrientation(static_cast<TRenderOrientation>(1000));

   788 	iWaitForPublishOnNextTest = EFalse;

   789 	IsOrientationCorrect(EDisplayOrientation90CW);

   790 	}

   792 /**

   793  @SYMTestCaseID             GRAPHICS-WSERV-DEVICEROTATION-0010

   794  @SYMTestCaseDesc           Test Invalid Theme Server Orientation

   795  @SYMPREQ                   ###TrackingDeviceRotation### TODO replace me

   796  @SYMTestPriority           1

   797  @SYMTestPurpose            To test that an invalid theme server orientation is ignored when

   798                             the app orientation has been set to auto.

   799  @SYMPrerequisites          An RProperty is set up to subscribe to notifications of

   800                             windowserver orientation changes.

   801                             An RProperty is set up to publish Theme server Orientation changes.

   802                             We have set up an RWindowGroup in ordinal position 0.

   803  @SYMTestActions            1) Set the theme server orientation to EDisplayOrientationNormal.

   804                             2) Set the RWindowGroup in ordinal position 0 to

   805                                EDisplayOrientationAuto.

   806                             4) Check the published orinetation value in windowserver.

   807                             5) Set the theme server orientation to an invalid orientation.

   808                             6) Check the published orinetation value in windowserver.

   810  @SYMTestExpectedResults    Wserv should publish an orientation change for 2) but not for 5).

   811                             The orientations checked in steps 4) and 6) should both be the

   812                             theme server orientation set in step 1).

   813 */

   814 void CTDeviceRotation::TestInvalidThemeServerOrientation()

   815 	{

   816 	SimulateThemeServerOrientation(EDisplayOrientationNormal);

   817 	TestIndicateAppOrientation(EDisplayOrientationAuto);

   818 	SimulateThemeServerOrientation(static_cast<TRenderOrientation>(5000));

   819 	iWaitForPublishOnNextTest = EFalse;

   820 	IsOrientationCorrect(EDisplayOrientationNormal);

   821 	}

   823 __CONSTRUCT_STEP__(DeviceRotation)

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--