diff -r 2717213c588a -r 171fae344dd4 graphicstest/uibench/src/trenderorientation.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicstest/uibench/src/trenderorientation.cpp	Fri Jul 16 11:45:55 2010 +0300
@@ -0,0 +1,269 @@
+// Copyright (c) 2010 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 Nokia test code 
+*/
+
+#include <w32std.h>
+
+#include <wspublishandsubscribedata.h>
+#include "trenderorientation.h"
+
+const TInt KPublishTimeout  = 1000000;  // 1 second in microseconds
+const TInt KNumIterations   = 20;
+
+// Values for the device orientation that we receive via P&S from the Theme Server
+// Must match those in renderorientationtracker.h, and, obviously, those used by the real theme server 
+const TUid  KThemeOrientationCategory   = {0x20022E82}; // == KHbPsHardwareCoarseOrientationCategoryUid 
+const TUint KThemeOrientationKey        = 0x4F726965; // == KHbPsHardwareCoarseOrientationKey 
+
+void CWindowStuff::ConstructL()
+    {
+    User::LeaveIfError(iWs.Connect());
+    iWs.SetAutoFlush(ETrue);
+    
+    iWindowGroup = RWindowGroup(iWs);
+    User::LeaveIfError(iWindowGroup.Construct(reinterpret_cast<TUint32>(&iWindowGroup)));
+    
+    iChildWindow = RWindow(iWs);
+    User::LeaveIfError(iChildWindow.Construct(iWindowGroup, reinterpret_cast<TUint32>(&iChildWindow)));
+    }
+
+CWindowStuff::~CWindowStuff()
+    {
+    Destroy();
+    }
+
+void CWindowStuff::Destroy()
+    {
+    iChildWindow.Close();
+    iWindowGroup.Close();
+    iWs.Close();    
+    }
+
+CTRenderOrientation::CTRenderOrientation()
+    {
+    // check that these two enums are aligned
+    __ASSERT_COMPILE(EDisplayOrientationAuto == ENumWindowThings);
+    
+    SetTestStepName(KTRenderOrientation);
+    }
+
+CTRenderOrientation::~CTRenderOrientation()
+    {
+    }
+
+TRenderOrientation CTRenderOrientation::GetRenderOrientationL()
+    {    
+    return GetOrientationL(iWsRenderOrientationProperty);    
+    }
+
+TRenderOrientation CTRenderOrientation::GetThemeOrientationL()
+    {    
+    return GetOrientationL(iThemeOrientationProperty);    
+    }
+
+TRenderOrientation CTRenderOrientation::GetOrientationL(RProperty& aProperty)
+    {
+    TInt orientation=EDisplayOrientationNormal;
+    User::LeaveIfError(aProperty.Get(orientation));
+    
+    TESTL(orientation >= EDisplayOrientationNormal);
+    TESTL(orientation < EDisplayOrientationAuto);    
+    
+    return static_cast<TRenderOrientation>(orientation);    
+    }
+
+void CTRenderOrientation::TestOrientationChangeL(const TDesC& aStepName, TTestPhase aTestPhase)
+    {
+    SetTestStepID(aStepName);
+    
+    if(EThemeOrientationChange == aTestPhase)
+        {               
+        TESTL(EDisplayOrientationNormal == GetThemeOrientationL());
+        iWindowStuff[EFirstWindowThing].Session().IndicateAppOrientation(EDisplayOrientationAuto);        
+        }
+    
+    TInt renderOrientation = GetRenderOrientationL();
+    
+    // For consistancy, check that we are starting from the same orientation
+    TESTL(EDisplayOrientationNormal == renderOrientation);    
+    
+    // Set-up the timer
+    iProfiler->InitResults();
+    iTimingsTaken = 0;    
+    
+    // repeat numerous times to get a decent average
+    for(TInt iterations=0; iterations < KNumIterations; ++iterations)
+        {
+        renderOrientation = GetRenderOrientationL();
+        // For consistancy, check that we are starting from the same orientation
+        TESTL(EDisplayOrientationNormal == renderOrientation);           
+        
+        // loop through the orientations, ending up changing back to normal
+        for(++renderOrientation; renderOrientation <= EDisplayOrientationAuto; ++renderOrientation)
+            {
+            // % can be slow, do it outside of the timing
+            TRenderOrientation testOrientation = static_cast<TRenderOrientation>(renderOrientation%EDisplayOrientationAuto);
+            
+            iWsRenderOrientationProperty.Subscribe(iRenderOrientationStatus);            
+            // start the timeout timer
+            iTimeoutTimer.After(iTimeoutStatus, KPublishTimeout);
+            // start the results timer
+            iProfiler->StartTimer();
+            
+            switch(aTestPhase)
+                {
+                case EIndicatedOrientationChange:
+                    // Do the indicated orientation Change
+                    iWindowStuff[EFirstWindowThing].Session().IndicateAppOrientation(testOrientation);
+                    break;
+                    
+                case EWindowOrdinalChange:
+                    // move the relevant window group to the front
+                    // N.B. this will go wrong if the number of orientations and windows are not equal
+                    iWindowStuff[testOrientation].WindowGroup().SetOrdinalPosition(0);
+                    break;
+                    
+                case EThemeOrientationChange:
+                    // Needs the focus window to be in auto mode
+                    iThemeOrientationProperty.Set(testOrientation);
+                    break;
+                    
+                default:
+                    TESTL(EFalse);
+                }
+        
+            // Wait for the update to have been published ( or time out while waiting )
+            User::WaitForRequest(iRenderOrientationStatus, iTimeoutStatus);
+            
+            iProfiler->MarkResultSetL();
+            ++iTimingsTaken;
+            
+            if(KErrNone != iRenderOrientationStatus.Int())
+                {
+                // timed out
+                iWsRenderOrientationProperty.Cancel();                
+                TESTL(EFalse);
+                }
+            else
+                {
+                // Check that it is actually the expected orientation
+                TESTL(GetRenderOrientationL() == testOrientation);
+                }
+
+            if(KRequestPending == iTimeoutStatus.Int())
+                {
+                // as expected, so cancel the timeout timer
+                iTimeoutTimer.Cancel();
+                }
+            else
+                {
+                // timed out
+                TESTL(EFalse);
+                }
+            }
+        }    
+    
+    // wrap it up    
+    iProfiler->ResultsAnalysis(KTRenderOrientation,KErrNotFound,ENone,ENone,iTimingsTaken);
+    }
+
+TVerdict CTRenderOrientation::doTestStepL()
+    {     
+    INFO_PRINTF1(_L("Testing: Indicated Orientation Change"));
+    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx1"), EIndicatedOrientationChange);
+    
+    INFO_PRINTF1(_L("Testing: Window Ordinal Position Change"));
+    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx2"), EWindowOrdinalChange);
+    
+    INFO_PRINTF1(_L("Testing: Theme Orientation Change"));
+    TestOrientationChangeL(_L("GRAPHICS-UI-BENCH-0xxx3"), EThemeOrientationChange);
+    
+    return TestStepResult();    
+    }
+
+_LIT(KThemeServerPropertyDefine, "twsthemeserverpropertydefine.exe");
+_LIT(KThemeServerPropertyDefineCmdDefine, "define");
+_LIT(KThemeServerPropertyDefineCmdDelete, "delete");   
+   
+void CTRenderOrientation::ThemeServerProperty(const TDesC& aCmd)
+    {
+    /* This Process called with the argument KThemeServerPropertyDefineCmdDelete, deletes 
+       the theme server RProperty. This is because an RProperty can only be defined and 
+       deleted from within a process with the same UID3 as the RProperty catogory you are 
+       trying to define/delete.*/
+    RProcess themeServerPropertyDefine;
+    TInt err = themeServerPropertyDefine.Create(KThemeServerPropertyDefine, aCmd);
+    if (KErrNone != err)
+        {
+        _LIT(KLog, "themeServerPropertyDefine.Create() failed with error: %d");
+        INFO_PRINTF2(KLog, err);
+        TEST(EFalse);        
+        }
+    
+    //wait for themeServerPropertyDefine process to terminate
+    TRequestStatus themeServerPropertyDefineLogonStatus;
+    themeServerPropertyDefine.Logon(themeServerPropertyDefineLogonStatus);
+    themeServerPropertyDefine.Resume();
+    User::WaitForRequest(themeServerPropertyDefineLogonStatus);
+    if (themeServerPropertyDefineLogonStatus != KErrNone)
+        {
+        _LIT(KLog, "themeServerPropertyDefine.Logon() failed with error: %d");
+        INFO_PRINTF2(KLog, themeServerPropertyDefineLogonStatus);
+        TEST(EFalse);        
+        }
+    themeServerPropertyDefine.Close();    
+    }
+
+TVerdict CTRenderOrientation::doTestStepPreambleL()
+    {
+    // Create in reverse order so that windowThing 0 is at the front
+    for(TInt windowThing = ENumWindowThings - 1; windowThing >= 0 ; --windowThing)
+        {
+        iWindowStuff[windowThing].ConstructL();
+        TRenderOrientation orientation = static_cast<TRenderOrientation>(windowThing%EDisplayOrientationAuto);
+        iWindowStuff[windowThing].Session().IndicateAppOrientation(orientation);
+        iWindowStuff[windowThing].WindowGroup().SetOrdinalPosition(0);
+        }
+    
+    User::LeaveIfError(iWsRenderOrientationProperty.Attach(KRenderOrientationCategory, KRenderOrientationKey));
+    
+    ThemeServerProperty(KThemeServerPropertyDefineCmdDefine);
+    User::LeaveIfError(iThemeOrientationProperty.Attach(KThemeOrientationCategory, KThemeOrientationKey));
+    
+    User::LeaveIfError(iTimeoutTimer.CreateLocal());
+    
+    return CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();
+    }
+
+TVerdict CTRenderOrientation::doTestStepPostambleL()
+    {
+    iTimeoutTimer.Close();
+    
+    iThemeOrientationProperty.Close();
+    ThemeServerProperty(KThemeServerPropertyDefineCmdDelete);    
+    iWsRenderOrientationProperty.Close();
+    
+    for(TInt windowThing = 0; windowThing < ENumWindowThings; ++windowThing)
+        {
+        iWindowStuff[windowThing].Destroy();
+        }
+    
+    return CTe_graphicsperformanceSuiteStepBase::doTestStepPostambleL();
+    }