Applied patch 1, to provide a syborg specific minigui oby file.
Need to compare this with the "stripped" version currently in the tree.
This supplied version applies for Nokia builds, but need to repeat the
test for SF builds to see if pruning is needed, or if the file needs to
be device-specific.
// Copyright (c) 1996-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:
// GWHANDLE.CPP
// Test group window handle functions
//
//
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "TGWHANDLE.H"
CTGwHandle::CTGwHandle(CTestStep* aStep):
CTWsGraphicsBase(aStep)
{
}
void CTGwHandle::ConstructL()
{
}
CTGwHandle::~CTGwHandle()
{
}
TInt CTGwHandle::NumberOfWndGroupsWithZeroPriority(TInt aScreenNumber)
{
__ASSERT_ALWAYS(aScreenNumber <= 1, User::Invariant());
return TheClient->iWs.NumWindowGroups(aScreenNumber,0);
}
void CTGwHandle::GetGwListL(CArrayFixFlat<TInt> *aWindowHandles)
{
User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles));
}
void CTGwHandle::GetGwListL(CArrayFixFlat<TInt> *aWindowHandles, TInt aScreenNumber)
{
User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles, aScreenNumber));
}
void CTGwHandle::GetGwListL(TInt aPriority, CArrayFixFlat<TInt> *aWindowHandles)
{
User::LeaveIfError(TheClient->iWs.WindowGroupList(aPriority,aWindowHandles));
}
void CTGwHandle::GetGwListL(RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
{
User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles));
}
void CTGwHandle::GetGwListL(TInt aPriority, RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
{
User::LeaveIfError(TheClient->iWs.WindowGroupList(aPriority, aWindowHandles));
}
void CTGwHandle::GwNamesL()
{
enum {EConnectHandle1=123456};
enum {EWindowGroupHandle1=234567};
enum {EWindowGroupHandle2=666666};
//
TInt foreground;
User::LeaveIfError(foreground=TheClient->iWs.GetFocusWindowGroup());
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
gw1.SetOwningWindowGroup(foreground);
RWindowGroup gw2(ws1);
User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
gw2.SetOwningWindowGroup(foreground);
//
TBuf<8> getName;
//
// Check default name is simply a null string
//
TInt retVal = gw1.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("gw1.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==_L(""));
if (getName!=_L(""))
INFO_PRINTF3(_L("getName==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
//
TBuf<8> name1(_L("A_Name1"));
TBuf<8> name2(_L("A_Name2"));
//
retVal = gw1.SetName(name1);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("gw1.SetName(name1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw2.SetName(name2);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.SetName(name2) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw1.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw1.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==name1);
if (getName!=name1)
INFO_PRINTF3(_L("getName==name1 - Expected: %d, Actual: %d"), ETrue, EFalse);
//
retVal = gw2.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==name2);
if (getName!=name2)
INFO_PRINTF3(_L("getName==name2 - Expected: %d, Actual: %d"), ETrue, EFalse);
//
// A few weird characters in the name should work fine
//
retVal = gw2.SetName(_L("xx*"));
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.SetName(_L(xx*)) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw2.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==_L("xx*"));
if (getName!=_L("xx*"))
INFO_PRINTF3(_L("getName==_L(xx*) - Expected: %d, Actual: %d"), ETrue, EFalse);
//
retVal = gw2.SetName(_L(":"));
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.SetName(_L(:)) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw2.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==_L(":"));
if (getName!=_L(":"))
INFO_PRINTF3(_L("getName==_L(:) - Expected: %d, Actual: %d"), ETrue, EFalse);
//
// Setting the name back to a null name
//
retVal = gw2.SetName(_L(""));
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("gw2.SetName(_L()) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw2.Name(getName);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(getName==_L(""));
if (getName!=_L(""))
INFO_PRINTF3(_L("getName==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
//
// Getting a name into a too short buffer should fill thew whole buffer from the left hand part
// of the window name and return KErrOverflow
//
gw2.SetName(name2);
TBuf<4> shortBuf;
retVal = gw2.Name(shortBuf);
TEST(retVal==KErrOverflow);
if (retVal!=KErrOverflow)
INFO_PRINTF3(_L("gw2.Name(shortBuf) return value - Expected: %d, Actual: %d"), KErrOverflow, retVal);
TEST(shortBuf==name2.Left(4));
if (shortBuf!=name2.Left(4))
INFO_PRINTF3(_L("shortBuf==name2.Left(4) - Expected: %d, Actual: %d"), ETrue, EFalse);
//
// passing a 0 length TPtr pointing to NULL should be safe, simply returning KErrOverflow
//
TPtr nullPtr(NULL,0);
retVal = gw2.Name(nullPtr);
TEST(retVal==KErrOverflow);
if (retVal!=KErrOverflow)
INFO_PRINTF3(_L("gw2.Name(nullPtr) return value - Expected: %d, Actual: %d"), KErrOverflow, retVal);
TEST(nullPtr==_L(""));
if (nullPtr!=_L(""))
INFO_PRINTF3(_L("nullPtr==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
//
// Getting a null name into a null descriptor
//
gw2.SetName(_L(""));
TPtr nullPtr2(NULL,0);
retVal = gw2.Name(nullPtr);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("gw2.Name(nullPtr) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
TEST(nullPtr2==_L(""));
if (nullPtr2!=_L(""))
INFO_PRINTF3(_L("nullPtr2==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
//
gw1.Close();
gw2.Close();
CleanupStack::PopAndDestroy(screen);
ws1.Close();
}
void CTGwHandle::GwIdentifierTestL()
{
enum {EWindowGroupHandle1=234567};
enum {EWindowGroupHandle2=666666};
enum {EWindowGroupHandle3=999};
//
CArrayFixFlat<TInt>* windowHandles=new(ELeave) CArrayFixFlat<TInt>(5);
CleanupStack::PushL(windowHandles);
GetGwListL(0, windowHandles);
TInt retVal = TheClient->iWs.GetFocusWindowGroup();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("TheClient->iWs.GetFocusWindowGroup() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
//
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
CleanupClosePushL(ws1);
// assign to the correct screen
CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen1);
User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
gw1.SetOwningWindowGroup((*windowHandles)[0]);
RWsSession ws2;
User::LeaveIfError(ws2.Connect());
CleanupClosePushL(ws2);
// assign to the correct screen
CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
CleanupStack::PushL(screen2);
User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
RWindowGroup gw2(ws2);
User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
//
GetGwListL(0, windowHandles);
//
retVal = gw2.Identifier();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("gw2.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
TEST(retVal==EWindowGroupHandle2);
if (retVal!=EWindowGroupHandle2)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle2, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
TEST(retVal==EWindowGroupHandle1);
if (retVal!=EWindowGroupHandle1)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
//
retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]);
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]);
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), 0, retVal);
//
TThreadId threadId;
TheClient->iWs.GetWindowGroupClientThreadId((*windowHandles)[0],threadId);
TUint64 ret = RThread().Id();
TEST(ret==threadId);
if (ret!=threadId)
INFO_PRINTF3(_L("RThread().Id() return value - Expected: %d, Actual: %d"), (TInt)threadId, (TInt)ret);
TheClient->iWs.GetWindowGroupClientThreadId((*windowHandles)[1],threadId);
TUint64 retVal2 = RThread().Id();
TEST(retVal2==threadId);
if (retVal2!=threadId)
INFO_PRINTF3(_L("RThread().Id() return value - Expected: %d, Actual: %d"), (TInt)threadId, (TInt)retVal2);
//
retVal = gw1.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = gw2.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],0);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],0) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw1.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = gw2.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
//
retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],1);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
retVal = gw1.OrdinalPosition();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
retVal = gw2.OrdinalPosition();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],1);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
GetGwListL(0, windowHandles);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
TEST(retVal==EWindowGroupHandle1);
if (retVal!=EWindowGroupHandle1)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
TEST(retVal==EWindowGroupHandle2);
if (retVal!=EWindowGroupHandle2)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle2, retVal);
//
RWindowGroup gw3(ws2);
User::LeaveIfError(gw3.Construct(EWindowGroupHandle3));
gw1.SetOrdinalPosition(0,100000); // Assume nothing else in the system is higher, else test will fail
gw3.SetOrdinalPosition(0,100000);
ws1.Flush();
ws2.Flush();
//
GetGwListL(100000, windowHandles);
retVal = windowHandles->Count();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), 2, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
TEST(retVal==EWindowGroupHandle3);
if (retVal!=EWindowGroupHandle3)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle3, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
TEST(retVal==EWindowGroupHandle1);
if (retVal!=EWindowGroupHandle1)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
//
retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]);
TEST(retVal==100000);
if (retVal!=100000)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), 100000, retVal);
retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]);
TEST(retVal==100000);
if (retVal!=100000)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), 100000, retVal);
//
GetGwListL(-12453, windowHandles); // Test 0 count, Assumes no window with priority
retVal = windowHandles->Count();
TEST(retVal==0);
if (retVal!=0)
INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), 0, retVal);
//
GetGwListL(windowHandles, iTest->iScreenNumber);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
TEST(retVal==EWindowGroupHandle3);
if (retVal!=EWindowGroupHandle3)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle3, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
TEST(retVal==EWindowGroupHandle1);
if (retVal!=EWindowGroupHandle1)
INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
//
// Check passing bad identifiers
//
retVal = TheClient->iWs.SetWindowGroupOrdinalPosition(-1,0);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition(-1,0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
retVal = TheClient->iWs.GetWindowGroupHandle(-3);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("TTheClient->iWs.GetWindowGroupHandle(-3) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
//
gw1.Close();
gw2.Close();
gw3.Close();
CleanupStack::PopAndDestroy(5, windowHandles);
}
void CTGwHandle::OwnerToForegroundL()
{
enum {EWindowGroupHandle1=234567};
enum {EWindowGroupHandle2a=666666};
enum {EWindowGroupHandle2b=666667};
//
CArrayFixFlat<TInt> *windowHandles=new(ELeave) CArrayFixFlat<TInt>(5);
CleanupStack::PushL(windowHandles);
GetGwListL(0, windowHandles);
TInt oldForeground=(*windowHandles)[0];
//
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
CleanupClosePushL(ws1);
// assign to the correct screen
CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen1);
User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
CleanupClosePushL(gw1);
RWsSession ws2;
User::LeaveIfError(ws2.Connect());
CleanupClosePushL(ws2);
// assign to the correct screen
CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
CleanupStack::PushL(screen2);
User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
RWindowGroup gw2a(ws2);
User::LeaveIfError(gw2a.Construct(EWindowGroupHandle2a));
CleanupClosePushL(gw2a);
RWindowGroup gw2b(ws2);
User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
CleanupClosePushL(gw2b);
gw1.SetOrdinalPosition(1);
//
// Turn auto flushing on as we're using multiple connections and it would be easy to forget to flush one
//
ws1.SetAutoFlush(ETrue);
ws2.SetAutoFlush(ETrue);
TheClient->iWs.SetAutoFlush(ETrue);
//
GetGwListL(0, windowHandles);
//
TInt retVal = gw2b.Identifier();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("gw2b.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
retVal = gw2a.Identifier();
TEST(retVal==(*windowHandles)[2]);
if (retVal!=(*windowHandles)[2])
INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
retVal = oldForeground;
TEST(retVal==(*windowHandles)[3]);
if (retVal!=(*windowHandles)[3])
INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[3], oldForeground);
//
CleanupStack::PopAndDestroy(&gw2b);
GetGwListL(0, windowHandles);
retVal = gw2a.Identifier();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
// Check 2a jumped over 1 in the ordinal list
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
retVal = oldForeground;
TEST(retVal==(*windowHandles)[2]);
if (retVal!=(*windowHandles)[2])
INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[2], oldForeground);
//
User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
CleanupClosePushL(gw2b);
gw2b.SetOwningWindowGroup(oldForeground);
CleanupStack::PopAndDestroy(&gw2b);
GetGwListL(0, windowHandles);
retVal = oldForeground;
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[0], oldForeground);
// Check old foreground bought to foreground
retVal = gw2a.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[2]);
if (retVal!=(*windowHandles)[2])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],2);
//
User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
CleanupClosePushL(gw2b);
gw2b.SetOwningWindowGroup((*windowHandles)[1]);
gw2b.SetOrdinalPosition(KOrdinalPositionSwitchToOwningWindow); // Should bring 2a to foreground
GetGwListL(0, windowHandles);
retVal = gw2a.Identifier();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
retVal = gw2b.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw2b.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[2]);
if (retVal!=(*windowHandles)[2])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
//
CleanupStack::PopAndDestroy(&gw2b);
GetGwListL(0, windowHandles);
retVal = gw2a.Identifier();
TEST(retVal==(*windowHandles)[0]);
if (retVal!=(*windowHandles)[0])
INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[1]);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
//
CleanupStack::PopAndDestroy(&gw2a); // Should bring shell to foreground
GetGwListL(0, windowHandles);
// check whether the shell is on
TThreadId threadId;
ws2.GetWindowGroupClientThreadId((*windowHandles)[0],threadId);
TBool shellRunning=ETrue;
TFullName shellName;
// apply to primary screen only where SHELL is running
TFindThread findThread(iTest->iScreenNumber==KDefaultScreen?_L("WSHELL*::*"):_L("WxSHELL*::*"));
if(findThread.Next(shellName)==KErrNone)
{
RThread shell;
User::LeaveIfError(shell.Open(shellName));
TEST(shell.Id()==threadId);
if (retVal!=(*windowHandles)[1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
shell.Close();
}
else
{
shellRunning=EFalse;
}
// Check gw1 second
retVal = gw1.Identifier();
TEST(retVal==(*windowHandles)[shellRunning ? 1 : 0]);
if (retVal!=(*windowHandles)[shellRunning ? 1 : 0])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[shellRunning ? 1 : 0], retVal);
retVal = oldForeground;
TEST(retVal==(*windowHandles)[shellRunning ? 2 : 1]);
if (retVal!=(*windowHandles)[shellRunning ? 2 : 1])
INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[shellRunning ? 2 : 1], retVal);
// and oldforeground second
//
CleanupStack::PopAndDestroy(5, &ws1);
//
// Kick shell back into background, 'cause that's where it belongs
//
TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],-1);
TheClient->iWs.SetAutoFlush(EFalse);
//
CleanupStack::PopAndDestroy(windowHandles);
}
void CTGwHandle::FindWindowGroupIdentifierTestL()
{
enum {EWindowGroupHandle1=234567};
enum {EWindowGroupHandle2=666666};
enum {EWindowGroupHandle3=123};
TInt foreground=TheClient->iWs.GetFocusWindowGroup();
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
CleanupStack::Pop(screen);
CleanupClosePushL(ws1);
//
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
CleanupClosePushL(gw1);
gw1.SetOwningWindowGroup(foreground);
RWindowGroup gw2(ws1);
User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
CleanupClosePushL(gw2);
gw1.SetOwningWindowGroup(foreground);
RWindowGroup gw3(ws1);
User::LeaveIfError(gw3.Construct(EWindowGroupHandle3));
CleanupClosePushL(gw3);
gw3.SetOwningWindowGroup(foreground);
//
TInt id1=gw1.Identifier();
TInt id2=gw2.Identifier();
TInt id3=gw3.Identifier();
//
gw1.SetName(_L("qwerty123abcd"));
gw2.SetName(_L("123"));
gw3.SetName(_L("qqqabcdxxx123"));
//
TInt retVal = ws1.FindWindowGroupIdentifier(0,_L("123"),0);
TEST(retVal==id2);
if (retVal!=id2)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(123),0) return value - Expected: %d, Actual: %d"), id2, retVal);
//
retVal = ws1.FindWindowGroupIdentifier(0,_L("*123*"),0);
TEST(retVal==id3);
if (retVal!=id3)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*123*),0) return value - Expected: %d, Actual: %d"), id3, retVal);
retVal = ws1.FindWindowGroupIdentifier(id3,_L("*123*"),0);
TEST(retVal==id2);
if (retVal!=id2)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*123*),0) return value - Expected: %d, Actual: %d"), id2, retVal);
retVal = ws1.FindWindowGroupIdentifier(id2,_L("*123*"),0);
TEST(retVal==id1);
if (retVal!=id1)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id2,_L(*123*),0) return value - Expected: %d, Actual: %d"), id1, retVal);
//
retVal = ws1.FindWindowGroupIdentifier(0,_L("*abcd*"),0);
TEST(retVal==id3);
if (retVal!=id3)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*abcd*),0) return value - Expected: %d, Actual: %d"), id3, retVal);
retVal = ws1.FindWindowGroupIdentifier(id3,_L("*abcd*"),0);
TEST(retVal==id1);
if (retVal!=id1)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*abcd*),0)return value - Expected: %d, Actual: %d"), id1, retVal);
//
retVal = ws1.FindWindowGroupIdentifier(0,_L("*123*"),7);
TEST(retVal==id3);
if (retVal!=id3)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*123*),7)return value - Expected: %d, Actual: %d"), id3, retVal);
retVal = ws1.FindWindowGroupIdentifier(id3,_L("*123*"),7);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*123*),7) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
retVal = ws1.FindWindowGroupIdentifier(0,_L("*abc*"),4);
TEST(retVal==id1);
if (retVal!=id1)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*abc*),4) return value - Expected: %d, Actual: %d"), id1, retVal);
retVal = ws1.FindWindowGroupIdentifier(id1,_L("*abc*"),4);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(*abc*),4) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
retVal = ws1.FindWindowGroupIdentifier(0,_L("xxx*"),7);
TEST(retVal==id3);
if (retVal!=id3)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(xxx*),7) return value - Expected: %d, Actual: %d"), id3, retVal);
retVal = ws1.FindWindowGroupIdentifier(0,_L("xxx*"),8);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(xxx*),8) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
//
retVal = ws1.FindWindowGroupIdentifier(id1,_L("12"),0);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(12),0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
retVal = ws1.FindWindowGroupIdentifier(id1,_L("qqq"),0);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(qqq),0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
retVal = ws1.FindWindowGroupIdentifier(id1,_L("abcd"),3);
TEST(retVal==KErrNotFound);
if (retVal!=KErrNotFound)
INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(abcd),3) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
//
delete screen;
CleanupStack::PopAndDestroy(4, &ws1);
}
void CTGwHandle::DefaultOwningWindowL()
{
TInt foreground=TheClient->iWs.GetFocusWindowGroup();
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
//
INFO_PRINTF1(_L("DefaultOwningWindow1"));
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(1));
gw1.SetOwningWindowGroup(foreground);
RWindowGroup gw2(ws1);
User::LeaveIfError(gw2.Construct(2));
gw2.SetOwningWindowGroup(foreground);
RWindowGroup gw3(ws1);
User::LeaveIfError(gw3.Construct(3));
gw3.SetOwningWindowGroup(foreground);
RWindowGroup gw4(ws1);
User::LeaveIfError(gw4.Construct(4));
gw4.SetOwningWindowGroup(foreground);
INFO_PRINTF1(_L(" Created Group Window"));
//
TInt prevOwningGroup=ws1.GetDefaultOwningWindow();
gw1.DefaultOwningWindow();
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
gw2.DefaultOwningWindow();
TEST(gw2.Identifier()==ws1.GetDefaultOwningWindow());
if (gw2.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw2.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw2.Identifier());
gw2.Close();
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
gw3.DefaultOwningWindow();
gw4.DefaultOwningWindow();
gw3.Close();
TEST(gw4.Identifier()==ws1.GetDefaultOwningWindow());
if (gw4.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw4.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw4.Identifier());
gw4.Close();
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
gw1.Close();
TEST(prevOwningGroup==ws1.GetDefaultOwningWindow());
if (prevOwningGroup!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("prevOwningGroup==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), prevOwningGroup);
INFO_PRINTF1(_L(" Closed Group Window"));
User::LeaveIfError(gw1.Construct(1));
gw1.SetOwningWindowGroup(foreground);
User::LeaveIfError(gw2.Construct(2));
gw2.SetOwningWindowGroup(foreground);
User::LeaveIfError(gw3.Construct(3));
gw3.SetOwningWindowGroup(foreground);
INFO_PRINTF1(_L(" ReCreated Group Window"));
gw1.DefaultOwningWindow();
gw1.DefaultOwningWindow();
gw1.Close();
gw2.DefaultOwningWindow();
gw2.DefaultOwningWindow();
gw3.Close();
gw2.Close();
INFO_PRINTF1(_L(" Re-Closed Group Window"));
User::LeaveIfError(gw1.Construct(1));
gw1.SetOwningWindowGroup(foreground);
User::LeaveIfError(gw2.Construct(2));
gw2.SetOwningWindowGroup(foreground);
User::LeaveIfError(gw3.Construct(3));
gw3.SetOwningWindowGroup(foreground);
User::LeaveIfError(gw4.Construct(4));
gw4.SetOwningWindowGroup(foreground);
INFO_PRINTF1(_L(" ReCreated Group Window Again"));
gw1.DefaultOwningWindow();
gw2.DefaultOwningWindow();
gw1.DefaultOwningWindow();
gw1.Close();
gw2.Close();
gw3.DefaultOwningWindow();
gw4.DefaultOwningWindow();
gw3.DefaultOwningWindow();
gw4.Close();
gw3.Close();
INFO_PRINTF1(_L(" Re-Closed Group Window Again"));
User::LeaveIfError(gw1.Construct(1));
gw1.DefaultOwningWindow();
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
gw1.DefaultOwningWindow();
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
User::LeaveIfError(gw2.Construct(2));
TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
gw2.Close();
gw1.Close();
CleanupStack::PopAndDestroy(screen);
ws1.Close();
}
void CTGwHandle::DefaultOwningWindow2L()
//This test originally resulted in a crash, while the above test originally resulted in lockups.
{
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
// assign to the correct screen
CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen1);
User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
RWsSession ws2;
User::LeaveIfError(ws2.Connect());
// assign to the correct screen
CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
CleanupStack::PushL(screen2);
User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
//
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(1));
RWindowGroup gw2(ws2);
User::LeaveIfError(gw2.Construct(2));
RWindowGroup gw3(ws1);
User::LeaveIfError(gw3.Construct(3));
//
const TInt gw1Id=gw1.Identifier();
gw1.DefaultOwningWindow();
gw2.DefaultOwningWindow();
/*const TInt gw2Id=*/gw2.Identifier();
gw1.DefaultOwningWindow();
TEST(gw1Id==ws1.GetDefaultOwningWindow());
if (gw1Id!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1Id);
gw3.DefaultOwningWindow();
gw3.Close();
TEST(gw1Id==ws1.GetDefaultOwningWindow());
if (gw1Id!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw1Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1Id);
gw1.Close();
TInt gw2Id=gw2.Identifier();
TEST(gw2Id==ws1.GetDefaultOwningWindow());
if (gw2Id!=ws1.GetDefaultOwningWindow())
INFO_PRINTF3(_L("gw2Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw2Id);
gw2.SetOrdinalPosition(0);
gw2.Close();
ws2.Flush();
TRawEvent rawEvent;
rawEvent.Set(TRawEvent::EKeyDown,32);
TheClient->iWs.SimulateRawEvent(rawEvent);
TheClient->iWs.Flush();
//
CleanupStack::PopAndDestroy(2,screen1);
ws1.Close();
ws2.Close();
}
#define FREQ 500
void CTGwHandle::IdentifierWrapAroundTestL()
{
TInt report=-1;
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(1));
gw1.EnableReceiptOfFocus(EFalse);
TInt id1=gw1.Identifier();
RWindowGroup gw2(ws1);
User::LeaveIfError(gw2.Construct(2));
gw2.EnableReceiptOfFocus(EFalse);
TInt id2=gw2.Identifier();
gw2.Close(); // Allow gw2 id to be re-used
TInt id3;
do
{
RWindowGroup gw3(ws1);
User::LeaveIfError(gw3.Construct(2));
gw3.EnableReceiptOfFocus(EFalse);
id3=gw3.Identifier();
if ((id3/FREQ)!=(report/FREQ)) // || id3<=10)
{
report=id3;
iTest->LogMessage(id3);
}
TEST(id3!=id1); // Check id1 is not re-used as the window hasn't been freed yet
if (id3==id1)
{
_LIT(KErr,"Window Group Id Reused!");
LOG_MESSAGE(KErr);
}
gw3.Close();
} while(id3!=id2);
CleanupStack::PopAndDestroy(screen);
ws1.Close();
}
void GwHandleDestroyWindow(TAny* aWindow)
{
static_cast<RWindowTreeNode*>(aWindow)->Destroy();
}
RWindowGroup* CTGwHandle::CreateWindowGroupLC(RWsSession& aWs,TUint32 aClientHandle,TInt aParentId/*=0*/)
{
RWindowGroup* gw=new(ELeave) RWindowGroup(aWs);
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,gw));
if (aParentId>0)
{
User::LeaveIfError(gw->ConstructChildApp(aParentId,aClientHandle,EFalse));
}
else
{
User::LeaveIfError(gw->Construct(aClientHandle,EFalse));
}
return gw;
}
void CTGwHandle::CreateGroupWindowsLC(RWsSession& aWs)
{
for(TInt ii=ENumGroups-1;ii>=0;--ii)
iGroups[ii]=CreateWindowGroupLC(aWs,ii);
}
void CTGwHandle::CreateChainedGroupWindowsLC(RWsSession& aWs,TBool aSecondChain)
{
TInt parentId=0;
for(TInt ii=ENumChained-1;ii>=0;--ii)
{
iChained[ii]=CreateWindowGroupLC(aWs,ENumGroups+ii,parentId);
parentId=iChained[ii]->Identifier();
}
if(aSecondChain)
{
parentId =0;
for(TInt ii=ENumChained-1;ii>=0;--ii)
{
iChained2[ii]=CreateWindowGroupLC(aWs,ENumGroups+ENumGroups+ii,parentId);
parentId=iChained2[ii]->Identifier();
}
}
}
void CTGwHandle::MoveGroups(RWindowGroup** aGroups,TInt aGp,TInt aNum,TInt aPos,TInt aInc/*=2*/)
{
TInt ii;
for(ii=aNum;ii>0;--ii)
{
aGroups[aGp]->SetOrdinalPosition(aPos);
aGp+=(aInc>0?1:-1);
aPos+=aInc;
}
}
void CTGwHandle::TestGroups(TInt aPos)
{
TInt retVal;
TInt ii = 0;
for(ii=0;ii<ENumChained;++ii)
{
retVal = iChained[ii]->OrdinalPosition();
TEST(retVal==aPos+ii);
if (retVal!=aPos+ii)
INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+ii, retVal);
}
for(ii=0;ii<ENumGroups;++ii)
{
retVal = iGroups[ii]->OrdinalPosition();
TInt ret = (ii<aPos?ii:ii+ENumChained);
TEST(retVal==ret);
if (retVal!=ret)
INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ret, retVal);
}
}
void CTGwHandle::TestGroupsBefore(TInt aPos)
{
TInt ii;
TInt retVal;
if (aPos>0)
{
for (ii=0;ii<aPos;++ii)
{
retVal = iGroups[ii]->OrdinalPosition();
TEST(retVal==ii);
if (retVal!=ii)
INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ii, retVal);
}
}
for (ii=0;ii<ENumChained;++ii)
{
retVal = iChained[ii]->OrdinalPosition();
TEST(retVal==aPos+2*ii);
if (retVal!=aPos+2*ii)
INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+2*ii, retVal);
}
for (ii=0;ii<ENumChained-1;++ii)
{
retVal = iGroups[aPos+ii]->OrdinalPosition();
TEST(retVal==aPos+1+2*ii);
if (retVal!=aPos+1+2*ii)
INFO_PRINTF3(_L("iGroups[aPos+ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+1+2*ii, retVal);
}
for (ii=aPos+ENumChained-1;ii<ENumGroups;++ii)
{
retVal = iGroups[ii]->OrdinalPosition();
TEST(retVal==ii+ENumChained);
if (retVal!=ii+ENumChained)
INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ii+ENumChained, retVal);
}
}
void CTGwHandle::WindowGroupChaining()
{
RWsSession& ws=TheClient->iWs;
CreateGroupWindowsLC(ws);
CreateChainedGroupWindowsLC(ws);
TestGroups(0);
TInt start,target,moveGp;
for(moveGp=0;moveGp<ENumChained;++moveGp)
{
for(target=0;target<ENumGroups+1;++target)
{
for(start=0;start<ENumGroups-ENumChained+2;++start)
{
if (target>start+1)
MoveGroups(iGroups,target-1,target-start-1,ENumChained+target-1,-1);
if (target<start && start>0)
MoveGroups(iGroups,0,start,0,1);
MoveGroups(iGroups,start,ENumChained-1,start+1);
TestGroupsBefore(start);
iChained[moveGp]->SetOrdinalPosition(target+moveGp);
TestGroups(target);
}
}
iChained[0]->SetOrdinalPosition(0);
TestGroups(0);
}
CleanupStack::PopAndDestroy(ENumGroups+ENumChained,iGroups[ENumGroups-1]);
}
void CTGwHandle::WindowGroupChaining2()
{
RWsSession& ws=TheClient->iWs;
RWindowGroup* chain1=CreateWindowGroupLC(ws,1);
chain1->SetOrdinalPosition(0,1);
RWindowGroup* chain2=CreateWindowGroupLC(ws,2,chain1->Identifier());
TInt retVal = chain2->OrdinalPriority();
TEST(retVal==1);
if (retVal!=1)
INFO_PRINTF3(_L("chain2->OrdinalPriority() return value - Expected: %d, Actual: %d"), 1, retVal);
chain1->SetOrdinalPosition(0,2);
retVal = chain2->OrdinalPriority();
TEST(retVal==2);
if (retVal!=2)
INFO_PRINTF3(_L("chain2->OrdinalPriority() return value - Expected: %d, Actual: %d"), 2, retVal);
chain2->SetOrdinalPosition(0,3);
retVal = chain1->OrdinalPriority();
TEST(retVal==3);
if (retVal!=3)
INFO_PRINTF3(_L("chain1->OrdinalPriority() return value - Expected: %d, Actual: %d"), 3, retVal);
CleanupStack::PopAndDestroy(2,chain1);
//Test that two different sessions can't chain window-groups without permisson.
//Both sessions must use the same screen.
RWsSession ws2;
User::LeaveIfError(ws2.Connect());
CleanupClosePushL(ws2);
chain1=CreateWindowGroupLC(ws2,1);
TInt id1=chain1->Identifier();
RWsSession ws3;
User::LeaveIfError(ws3.Connect());
CleanupClosePushL(ws3);
RWindowGroup chain(ws3);
RDebug::Print(KPlatsecBegin);
retVal = chain.ConstructChildApp(id1,2);
TEST(retVal==KErrPermissionDenied);
if (retVal!=KErrPermissionDenied)
INFO_PRINTF3(_L("chain.ConstructChildApp(id1,2) return value - Expected: %d, Actual: %d"), KErrPermissionDenied, retVal);
RDebug::Print(KPlatsecEnd);
chain1->AllowProcessToCreateChildWindowGroups(TUid::Uid(0x10205152)); //Secure ID
retVal = chain.ConstructChildApp(id1,2);
TEST(retVal==KErrNone);
if (retVal!=KErrNone)
INFO_PRINTF3(_L("chain.ConstructChildApp(id1,2) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
chain.Close();
CleanupStack::PopAndDestroy(3,&ws2);
}
void CTGwHandle::UnchainWindowGroupsL()
{
RArray<RWsSession::TWindowGroupChainInfo>* windowHandles=new(ELeave) RArray<RWsSession::TWindowGroupChainInfo>;
CleanupStack::PushL(windowHandles);
GetGwListL(0,windowHandles);
TInt shellWindow=windowHandles->Count();
//Creating chained window groups.
CreateChainedGroupWindowsLC(TheClient->iWs);
GetGwListL(0,windowHandles);
//Test total window groups in the list
TInt retVal = windowHandles->Count();
TEST(retVal==ENumChained+shellWindow);
if (retVal!=ENumChained+shellWindow)
INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), ENumChained+shellWindow, retVal);
//Two unchained group windows
//Test Parent Id
TInt parentId=0;
for(TInt ii=ENumChained-1;ii>=0;ii--)
{
RWsSession::TWindowGroupChainInfo window;
window.iId=iChained[ii]->Identifier();
TInt loc=windowHandles->Find(window);
TEST(loc!=KErrNotFound);
if (loc==KErrNotFound)
INFO_PRINTF3(_L("windowHandles->Find(window) return value - Expected: %d, Actual: %d"), KErrNotFound, loc);
if(loc!=KErrNotFound)
{
TEST((*windowHandles)[loc].iParentId==parentId);
if ((*windowHandles)[loc].iParentId!=parentId)
INFO_PRINTF3(_L("(*windowHandles)[loc].iParentId==parentId - Expected: %d, Actual: %d"), parentId, (*windowHandles)[loc].iParentId);
parentId=window.iId;
}
}
//Test unchaining of chained window groups
for(TInt count=ENumChained-1;count>=0;count--)
{
iChained[count]->Close();
GetGwListL(0,windowHandles);
TEST(windowHandles->Count()== count+shellWindow);
if (windowHandles->Count()!= count+shellWindow)
INFO_PRINTF3(_L("windowHandles->Count()==count+shellWindow - Expected: %d, Actual: %d"), count+shellWindow, windowHandles->Count());
}
CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
//delete middle windowgroup of chain which should kill all the child windows
CreateChainedGroupWindowsLC(TheClient->iWs);
TInt windowPos=2;
CleanupStack::Pop(2,iChained[1]); //Pop first 2 items iChained[0] and iChained[1]
iChained[windowPos]->Close();//Close the 3rd WindowGroup in the chain.should unchain 4 and 5 window group.
CleanupStack::PopAndDestroy(iChained[windowPos]);
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
GetGwListL(0,windowHandles);
retVal = ChainedWindowCount(windowHandles);
TEST(retVal==ENumChained-windowPos-1);
if (retVal!=ENumChained-windowPos-1)
INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-1, retVal);
// CleanupStack::PopAndDestroy(ENumChained-1,iChained[ENumChained-1]);
windowPos=3;
CleanupStack::Pop(2,iChained[1]);
iChained[windowPos]->Close();//Close the 2nd WindowGroup in the chain.
//should unchain all .
CleanupStack::PopAndDestroy(iChained[windowPos]);
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
GetGwListL(0,windowHandles);
retVal = ChainedWindowCount(windowHandles);
TEST(retVal==ENumChained-windowPos-2);
if (retVal!=ENumChained-windowPos-2)
INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-2, retVal);
windowPos=4;
CleanupStack::Pop(2,iChained[1]);
iChained[windowPos]->Close();//Closing parent window group in chain. There should be no chain
CleanupStack::PopAndDestroy(iChained[windowPos]);
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
GetGwListL(0,windowHandles);
retVal = ChainedWindowCount(windowHandles);
TEST(retVal==ENumChained-windowPos-1);
if (retVal!=ENumChained-windowPos-1)
INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-1, retVal);
CleanupStack::PopAndDestroy(ENumChained-3,iChained[ENumChained-4]);
windowHandles->Close();
CleanupStack::PopAndDestroy(windowHandles);
}
TInt CTGwHandle::ChainedWindowCount(RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
{
TInt wndGrpCount=0;
for(TInt ii=0;ii<aWindowHandles->Count();ii++)
{
if((*aWindowHandles)[ii].iParentId!=-1)
wndGrpCount++;
}
return wndGrpCount;
}
void CTGwHandle::TestOrdinalPositionL()
{
TInt noOfGroupWnds = NumberOfWndGroupsWithZeroPriority(iTest->iScreenNumber);
//Creating the chained window groups
CreateChainedGroupWindowsLC(TheClient->iWs);
TestOrdinalPos(0);
//Test the ordinal position of all chained windows by setting the WndPos window
//to chainPos position
for(TInt wndPos=0;wndPos<ENumChained;wndPos++)
{
for(TInt chainPos=0;chainPos<15;chainPos++)
{
iChained[wndPos]->SetOrdinalPosition(chainPos);
TInt dung = chainPos-wndPos;
if(dung > noOfGroupWnds)
{
dung = noOfGroupWnds;
}
dung = Max(dung, 0);
TestOrdinalPos(chainPos - wndPos > noOfGroupWnds ? noOfGroupWnds : Max(chainPos - wndPos, 0));
}
}
//Test for negative ordinal number
iChained[0]->SetOrdinalPosition(-2);
TestOrdinalPos(noOfGroupWnds);
CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
}
void CTGwHandle::TestOrdinalPositionNoDebugL()
{
TInt noOfGroupWnds = NumberOfWndGroupsWithZeroPriority(iTest->iScreenNumber);
//Creating the chained window groups
CreateChainedGroupWindowsLC(TheClient->iWs);
//Test the ordinal position of all chained windows
TestOrdinalPosNoDebug(0);
//Test the ordinal position of all chained windows by setting the WndPos window
//to chainPos position
for(TInt wndPos=0;wndPos<ENumChained;wndPos++)
{
for(TInt chainPos=0;chainPos<15;chainPos++)
{
iChained[wndPos]->SetOrdinalPosition(chainPos);
TestOrdinalPosNoDebug(chainPos - wndPos > noOfGroupWnds ? noOfGroupWnds : Max(chainPos - wndPos, 0));
}
}
//Test for negative ordinal number
iChained[0]->SetOrdinalPosition(-2);
TestOrdinalPosNoDebug(noOfGroupWnds);
CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
}
void CTGwHandle::TestOrdinalPos(TInt aPos)
{
for(TInt ii=0;ii<ENumChained;ii++)
{
TInt iCha = iChained[ii]->OrdinalPosition();
TEST(iCha==aPos++);
if (iCha!=aPos-1)
{
INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos-1, iCha);
}
}
}
void CTGwHandle::TestOrdinalPosNoDebug(TInt aPos)
{
for(TInt ii=0;ii<ENumChained;ii++)
{
TInt iCha = iChained[ii]->OrdinalPosition();
TEST(iCha==aPos++);
if (iCha!=aPos-1)
INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos-1, iCha);
}
}
void CTGwHandle:: TestclosingclientL()
{
RWsSession ws1;
User::LeaveIfError(ws1.Connect());
CleanupClosePushL(ws1);
// assign to the correct screen
CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
CleanupStack::PushL(screen);
User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
// Creating first Window Group
RWindowGroup gw1(ws1);
User::LeaveIfError(gw1.Construct(ENullWsHandle));
ws1.SetWindowGroupOrdinalPosition(gw1.Identifier(),0);
// Creating second Window Group
RWindowGroup gw2(ws1);
User::LeaveIfError(gw2.Construct(ENullWsHandle));
gw2.SetOwningWindowGroup(gw1.Identifier());
gw2.SetOrdinalPosition(1);
CleanupStack::PopAndDestroy(screen);
CleanupStack::PopAndDestroy(&ws1);
}
void CTGwHandle::TestClearingAndSettingChildGroupsL()
{
RArray<RWsSession::TWindowGroupChainInfo> windowHandles;
CleanupClosePushL(windowHandles);
//Creating a chain of 5 window groups.
CreateChainedGroupWindowsLC(TheClient->iWs);
TInt ret=KErrNone;
// Want to test clearing and setting of window groups for chain lengths of 5 down to 2
for(TInt jj=ENumChained-1;jj>0;jj--)
{
// For each window group in the chain, test clearing and setting a child group
for(TInt ii=jj;ii>0;ii--)
{
RWsSession::TWindowGroupChainInfo window1;
window1.iId=iChained[ii]->Identifier();
GetGwListL(0,&windowHandles);
TInt loc=windowHandles.Find(window1);
TEST(loc!=KErrNotFound);
if(loc!=KErrNotFound)
{
RWsSession::TWindowGroupChainInfo window2;
window2.iId=iChained[ii-1]->Identifier();
loc = windowHandles.Find(window2);
TEST(loc!=KErrNotFound);
// First test that the parent of the next window in the chain is the previous in the chain
if(loc!=KErrNotFound)
{
TEST(windowHandles[loc].iParentId==window1.iId);
}
// Then clear and test that the parent of the next window in the chain
// is no longer the previous window in the chain
ret=iChained[ii]->ClearChildGroup();
TEST(ret==KErrNone);
// Try to clear a child group when it's already cleared - should return KErrArgument
ret=iChained[ii]->ClearChildGroup();
TEST(ret==KErrArgument);
GetGwListL(0,&windowHandles);
loc = windowHandles.Find(window2);
TEST(loc!=KErrNotFound);
// Test that it has no parent (0) or is unchained (-1)
if(loc!=KErrNotFound)
{
if(ii==1) // last in chain therefore unchained, should return -1
TEST(windowHandles[loc].iParentId==-1);
else // otherwise should return 0 signifying in a chain but with no parent
TEST(windowHandles[loc].iParentId==0);
}
// Reset the former child group as a child to the current group
ret=iChained[ii]->SetChildGroup(window2.iId);
TEST(ret==KErrNone);
// Test that it has now got it's parent back
GetGwListL(0,&windowHandles);
loc = windowHandles.Find(window2);
TEST(loc!=KErrNotFound);
if(loc!=KErrNotFound)
{
TEST(windowHandles[loc].iParentId==window1.iId);
}
}
}
// Reduce chain length by 1
ret=iChained[jj]->ClearChildGroup();
TEST(ret==KErrNone);
}
// Try to clear the child group of a window that's not in a queue - returns KErrArgument
ret=iChained[0]->ClearChildGroup();
TEST(ret==KErrArgument);
// Test calling set on a non-existent window group - fictional id, larger than what exists
ret=iChained[0]->SetChildGroup(9999);
TEST(ret==KErrArgument);
// Cleanup
CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
CleanupStack::PopAndDestroy(&windowHandles);
}
void CTGwHandle::TestAgainstLoopsWhenAddingChildGroupsL()
{
//Creating two chains of 5 window groups.
CreateChainedGroupWindowsLC(TheClient->iWs,ETrue);
TInt ret=KErrNone;
//Try to append any of element of this chain to the lastone (itself included)
//All these attempts should fail (otherwise a infinite loop will be set up)
for(TInt ii=ENumChained-1;ii>=0;ii--)
{
TInt windowId = iChained[ii]->Identifier();
// Try to append it to the last one
ret=iChained[0]->SetChildGroup(windowId);
TEST(ret==KErrArgument);
if(ret!=KErrArgument)
{
_LIT(KLog,"Error: SetChildGroup with a GpWin belonging to the same queue succeeded, return value :%d");
LOG_MESSAGE2(KLog,ret);
}
}
//Try to append any elements belonging to another chain to the last one of this chain
//All these trials should fail (otherwise a infinite loop will be set up)
//Except for the parent of the second chain.
for(TInt ii=0;ii<ENumChained;ii++)
{
TInt windowId = iChained2[ii]->Identifier();
// Try to append it to the last one
ret=iChained[0]->SetChildGroup(windowId);
if(ii != ENumChained-1)
{
TEST(ret==KErrArgument);
if(ret!=KErrArgument)
{
_LIT(KLog,"Error: SetChildGroup with a GpWin which already has a parent succeeded, return value :%d");
LOG_MESSAGE2(KLog,ret);
}
iChained[0]->ClearChildGroup();
}
else
{
TEST(ret==KErrNone);
if(ret!=KErrNone)
{
_LIT(KLog,"Error: SetChildGroup with a GpWin with no parent failed, return value :%d");
LOG_MESSAGE2(KLog,ret);
}
}
}
TInt windowId = iChained2[ENumChained-1]->Identifier();
ret=iChained[ENumChained-1]->SetChildGroup(windowId);
TEST(ret==KErrArgument);
if(ret!=KErrArgument)
{
_LIT(KLog,"Error: SetChildGroup successful on a GpWin which already has a child, return value :%d");
LOG_MESSAGE2(KLog,ret);
}
//Now take a window group not belonging to any queue
//just take the parent's chain and pop it
//and try to append it to itself
ret=iChained[ENumChained-1]->ClearChildGroup();
TEST(ret==KErrNone);
ret=iChained[ENumChained-1]->SetChildGroup(iChained[ENumChained-1]->Identifier());
TEST(ret==KErrArgument);
if(ret!=KErrArgument)
{
_LIT(KLog,"Error: Setting GpWin as a child of itself succeeded, return value :%d");
LOG_MESSAGE2(KLog,ret);
}
CleanupStack::PopAndDestroy(ENumChained+ENumChained,iChained[ENumChained-1]);
}
void CTGwHandle::RunTestCaseL(TInt /*aCurTestCase*/)
{
_LIT(KTest0,"Window group names");
_LIT(KTest1,"Window group identifiers");
_LIT(KTest2,"Owner to foreground");
_LIT(KTest3,"FindWindowGroupIdentifier test");
_LIT(KTest4,"IdentifierWrapAround test");
_LIT(KTest5,"DefaultOwningWindow test");
_LIT(KTest6,"DefaultOwningWindow2 test");
_LIT(KTest7,"Window Group Chaining");
_LIT(KTest8,"Window Group Chaining2");
_LIT(KTest9,"Unchaining window group");
_LIT(KTest10,"Ordinal Postion Test");
_LIT(KTest11,"CrashTest on closing client");
_LIT(KTest12,"Setting and Clearing Child Groups");
_LIT(KTest13,"No Infinite Loops in Setting Child Groups");
((CTGwHandleStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
switch(++iTest->iState)
{
/**
@SYMTestCaseID GRAPHICS-WSERV-0316
@SYMDEF DEF081259
@SYMTestCaseDesc Test setting window group names
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set the name of a window group to different values and check the
value is set correctly
@SYMTestExpectedResults The window group name is set correctly
*/
case 1:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0316"));
//iState=9; break;
iTest->LogSubTest(KTest0);
GwNamesL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0317
@SYMDEF DEF081259
@SYMTestCaseDesc Test setting window group identifiers
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set the identifiers of a window groups. manipulate the window groups and
check the identifiers remain correct
@SYMTestExpectedResults The identifiers are correct for each window group after
manipulation
*/
case 2:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0317"));
iTest->LogSubTest(KTest1);
GwIdentifierTestL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0318
@SYMDEF DEF081259
@SYMTestCaseDesc Test moving different window groups to the foreground and bringing
back the backgorund
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create some window groups and move them in turn to the foreground before
restoring the background
@SYMTestExpectedResults Window groups move to and from the foreground with error
*/
case 3:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0318"));
iTest->LogSubTest(KTest2);
OwnerToForegroundL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0319
@SYMDEF DEF081259
@SYMTestCaseDesc Test returning different window groups identifiers by searching
on the name
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create some window groups and return their identifiers by searching on
their names
@SYMTestExpectedResults The correct identifiers are returned for each name
*/
case 4:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0319"));
iTest->LogSubTest(KTest3);
FindWindowGroupIdentifierTestL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0320
@SYMDEF DEF081259
@SYMTestCaseDesc Test that a windows group identifier is not used twice
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Assign a window group identifier to one window group and check
the same identifier can not be used for a second group
@SYMTestExpectedResults Window group identifier can not be reused
*/
case 5:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0320"));
iTest->LogSubTest(KTest4);
IdentifierWrapAroundTestL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0321
@SYMDEF DEF081259
@SYMTestCaseDesc Test that the default owning window for window groups is set
correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set different default owning windows for different window groups.
Check the windows have been set correctly.
@SYMTestExpectedResults The default owning windows for the groups are set correctly
*/
case 6:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0321"));
iTest->LogSubTest(KTest5);
DefaultOwningWindowL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0322
@SYMDEF DEF081259
@SYMTestCaseDesc Test that the default owning window for window groups is set
correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Set different default owning windows for different window groups.
Check the windows have been set correctly.
@SYMTestExpectedResults The default owning windows for the groups are set correctly
*/
case 7:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0322"));
iTest->LogSubTest(KTest6);
DefaultOwningWindow2L();
TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0323
@SYMDEF DEF081259
@SYMTestCaseDesc Test that window groups can be chained correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create a chain of window groups and check that the chain of groups
can be manipluated correctly
@SYMTestExpectedResults The chain can be manipulated correctly
*/
case 8:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0323"));
iTest->LogSubTest(KTest7);
WindowGroupChaining();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0324
@SYMDEF DEF081259
@SYMTestCaseDesc Test that window groups can be chained correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create a chain of window groups and check that the chain of groups
can be manipluated correctly
@SYMTestExpectedResults The chain can be manipulated correctly
*/
case 9:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0324"));
iTest->LogSubTest(KTest8);
WindowGroupChaining2();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0325
@SYMDEF DEF081259
@SYMTestCaseDesc Test that window groups can be unchained correctly
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create chains of window groups and check that the window groups can be
unchained correctly
@SYMTestExpectedResults The chain can be unchained correctly
*/
case 10:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0325"));
iTest->LogSubTest(KTest9);
UnchainWindowGroupsL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0326
@SYMDEF DEF081259
@SYMTestCaseDesc Test the ordinal position of chained window groups
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create chains of window groups and check their ordinal position is correct
for different scenarios
@SYMTestExpectedResults Ordinal position of chained window group is correct
*/
case 11:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0326"));
iTest->LogSubTest(KTest10);
TestOrdinalPositionL();
break;
case 12:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0326"));
iTest->LogSubTest(KTest10);
TestOrdinalPositionNoDebugL();
break;
/**
@SYMTestCaseID GRAPHICS-WSERV-0327
@SYMDEF DEF081259
@SYMTestCaseDesc Test that window groups are dealt with correctly if their client is closed
@SYMTestPriority High
@SYMTestStatus Implemented
@SYMTestActions Create window groups and then close there client.
@SYMTestExpectedResults The window groups of the closed client are handled without error
*/
case 13:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
iTest->LogSubTest(KTest11);
TestclosingclientL();
break;
case 14:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
iTest->LogSubTest(KTest12);
TestClearingAndSettingChildGroupsL();
break;
case 15:
((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
iTest->LogSubTest(KTest13);
TestAgainstLoopsWhenAddingChildGroupsL();
break;
default:
((CTGwHandleStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
((CTGwHandleStep*)iStep)->CloseTMSGraphicsStep();
TestComplete();
break;
}
((CTGwHandleStep*)iStep)->RecordTestResultL();
}
__WS_CONSTRUCT_STEP__(GwHandle)