|
1 // Copyright (c) 1996-2009 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 // ORDINAL.CPP |
|
15 // Test ordinal position and priority changes on windows |
|
16 // |
|
17 // |
|
18 |
|
19 /** |
|
20 @file |
|
21 @test |
|
22 @internalComponent - Internal Symbian test code |
|
23 */ |
|
24 |
|
25 #include "TORDINAL.H" |
|
26 |
|
27 _LIT(KLogNextSibling,"NextSibling of iChild%d is not iChild%d"); |
|
28 _LIT(KLogNoNextSibling,"iChild%d has a NextSibling when it shouldn't"); |
|
29 _LIT(KLogPrevSibling,"PrevSibling of iChild%d is not iChild%d"); |
|
30 _LIT(KLogNoPrevSibling,"iChild%d has a PrevSibling when it shouldn't"); |
|
31 |
|
32 CTOrdinal::CTOrdinal(CTestStep* aStep): |
|
33 CTWsGraphicsBase(aStep) |
|
34 { |
|
35 } |
|
36 |
|
37 COrdinalWindowBase::COrdinalWindowBase(CTClient *aClient, CTestBase* aTest, CTestStep* aTestStep) : iClient(aClient), iTest(aTest), iTestStep(aTestStep) |
|
38 { |
|
39 } |
|
40 |
|
41 COrdinalWindow::COrdinalWindow(CTClient *aClient, CTestBase* aTest, CTestStep* aTestStep) : COrdinalWindowBase(aClient, aTest, aTestStep), iClientWin(aClient->iWs) |
|
42 { |
|
43 __DECLARE_NAME(_S("COrdinalWindow")); |
|
44 } |
|
45 |
|
46 COrdinalWindowGroup::COrdinalWindowGroup(CTClient *aClient, CTestBase* aTest, CTestStep* aTestStep) : COrdinalWindowBase(aClient, aTest, aTestStep), iGroupWin(aClient->iWs) |
|
47 { |
|
48 __DECLARE_NAME(_S("COrdinalWindowGroup")); |
|
49 } |
|
50 |
|
51 COrdinalWindowBase::~COrdinalWindowBase() |
|
52 { |
|
53 if (iWin) |
|
54 iWin->Close(); |
|
55 } |
|
56 |
|
57 void COrdinalWindowBase::Draw() |
|
58 {} |
|
59 |
|
60 inline RWindowTreeNode* COrdinalWindowBase::WinTreeNode() |
|
61 { |
|
62 return(iWin); |
|
63 } |
|
64 |
|
65 inline TUint32 COrdinalWindowBase::Handle() |
|
66 { |
|
67 return reinterpret_cast<TUint>(this); |
|
68 } |
|
69 |
|
70 COrdinalWindowBase *COrdinalWindowGroup::NewL(CTClient *aClient, CTestBase* aTest, CTestStep* aTestStep) |
|
71 { |
|
72 COrdinalWindowGroup *oWin=new(ELeave) COrdinalWindowGroup(aClient, aTest, aTestStep); |
|
73 TInt err=oWin->iGroupWin.Construct((TUint32)oWin); |
|
74 if (err<0) |
|
75 { |
|
76 delete oWin; |
|
77 User::Leave(err); |
|
78 } |
|
79 oWin->iWin= &oWin->iGroupWin; |
|
80 return(oWin); |
|
81 } |
|
82 |
|
83 COrdinalWindowBase *COrdinalWindow::NewL(CTClient* aClient, RWindowTreeNode* aParent, CTestBase* aTest, CTestStep* aTestStep) |
|
84 { |
|
85 COrdinalWindow *oWin=new(ELeave) COrdinalWindow(aClient, aTest, aTestStep); |
|
86 TInt err=oWin->iClientWin.Construct(*aParent,(TUint32)oWin); |
|
87 if (err!=KErrNone) |
|
88 { |
|
89 delete oWin; |
|
90 User::Leave(err); |
|
91 } |
|
92 oWin->iClientWin.Activate(); |
|
93 oWin->iWin= &oWin->iClientWin; |
|
94 return(oWin); |
|
95 } |
|
96 |
|
97 TInt COrdinalWindowBase::OrdinalPosition() |
|
98 { |
|
99 return(iWin->OrdinalPosition()); |
|
100 } |
|
101 |
|
102 void COrdinalWindowBase::SetOrdinalPosition(TInt aPos) |
|
103 { |
|
104 iWin->SetOrdinalPosition(aPos); |
|
105 } |
|
106 |
|
107 void COrdinalWindowBase::SetOrdinalPosition(TInt aPos,TInt aPri) |
|
108 { |
|
109 iWin->SetOrdinalPosition(aPos,aPri); |
|
110 } |
|
111 |
|
112 CTOrdinal::~CTOrdinal() |
|
113 { |
|
114 delete iClient; |
|
115 } |
|
116 |
|
117 void DZ(COrdinalWindowBase * &aX) |
|
118 { |
|
119 delete aX; |
|
120 aX=NULL; |
|
121 } |
|
122 |
|
123 void CTOrdinal::DestroyWindows() |
|
124 { |
|
125 DZ(iParent); |
|
126 DZ(iParent2); |
|
127 DZ(iParent3); |
|
128 for(TInt child=0;child<ENumChildren;++child) |
|
129 DZ(iChild[child]); |
|
130 } |
|
131 |
|
132 void COrdinalWindowBase::TestOP(TInt aTestPos) |
|
133 { |
|
134 iTestStep->TEST(iWin->OrdinalPosition()==aTestPos); |
|
135 } |
|
136 |
|
137 void COrdinalWindowBase::SetAndTestOP(TInt aPos,TInt aTestPos) |
|
138 { |
|
139 iWin->SetOrdinalPosition(aPos); |
|
140 iTestStep->TEST(iWin->OrdinalPosition()==aTestPos); |
|
141 } |
|
142 |
|
143 void COrdinalWindowBase::SetAndTestOP(TInt aPos) |
|
144 { |
|
145 SetAndTestOP(aPos, aPos); |
|
146 } |
|
147 |
|
148 TInt COrdinalWindowBase::SetToLastAndGetOP() |
|
149 { |
|
150 iWin->SetOrdinalPosition(-1); |
|
151 return(iWin->OrdinalPosition()); |
|
152 } |
|
153 |
|
154 TInt COrdinalWindowBase::SetToLastAndGetOPPri(TInt aPri) |
|
155 { |
|
156 iWin->SetOrdinalPosition(-1, aPri); |
|
157 return(iWin->OrdinalPosition()); |
|
158 } |
|
159 |
|
160 void COrdinalWindowBase::SetAndTestOPPri(TInt aPos,TInt aPri,TInt aTestPos) |
|
161 { |
|
162 iWin->SetOrdinalPosition(aPos,aPri); |
|
163 iTestStep->TEST(iWin->OrdinalPosition()==aTestPos); |
|
164 iTestStep->TEST(iWin->OrdinalPriority()==aPri); |
|
165 } |
|
166 |
|
167 void COrdinalWindowBase::SetAndTestOPPri(TInt aPos,TInt aPri) |
|
168 { |
|
169 SetAndTestOPPri(aPos,aPri,aPos); |
|
170 } |
|
171 |
|
172 inline COrdinalWindowBase* COrdinalWindowBase::NextSibling() const |
|
173 { |
|
174 return reinterpret_cast<COrdinalWindow*>(iWin->NextSibling()); |
|
175 } |
|
176 |
|
177 inline COrdinalWindowBase* COrdinalWindowBase::PrevSibling() const |
|
178 { |
|
179 return reinterpret_cast<COrdinalWindow*>(iWin->PrevSibling()); |
|
180 } |
|
181 |
|
182 void CTOrdinal::TestWindowOrderNext(TInt aBefore,TInt aAfter) |
|
183 { |
|
184 TInt retVal=(iChild[aBefore]->NextSibling()==iChild[aAfter]); |
|
185 TEST(retVal); |
|
186 if (!retVal) |
|
187 LOG_MESSAGE3(KLogNextSibling,aBefore,aAfter); |
|
188 } |
|
189 |
|
190 void CTOrdinal::TestWindowOrderNext(TInt aLast) |
|
191 { |
|
192 TInt retVal=(iChild[aLast]->NextSibling()==0); |
|
193 TEST(retVal); |
|
194 if (!retVal) |
|
195 LOG_MESSAGE2(KLogNoNextSibling,aLast); |
|
196 } |
|
197 |
|
198 void CTOrdinal::TestWindowOrderPrev(TInt aAfter,TInt aBefore) |
|
199 { |
|
200 TInt retVal=(iChild[aAfter]->PrevSibling()==iChild[aBefore]); |
|
201 TEST(retVal); |
|
202 if (!retVal) |
|
203 LOG_MESSAGE3(KLogPrevSibling,aAfter,aBefore); |
|
204 } |
|
205 |
|
206 void CTOrdinal::TestWindowOrderPrev(TInt aFirst) |
|
207 { |
|
208 TInt retVal=(iChild[aFirst]->PrevSibling()==0); |
|
209 TEST(retVal); |
|
210 if (!retVal) |
|
211 LOG_MESSAGE2(KLogNoPrevSibling,aFirst); |
|
212 } |
|
213 |
|
214 void CTOrdinal::OrdinalPos() |
|
215 { |
|
216 TInt last=iChild[0]->SetToLastAndGetOP(); |
|
217 iChild[0]->SetAndTestOP(0); |
|
218 iChild[5]->TestOP(5); |
|
219 iChild[1]->SetAndTestOP(3); |
|
220 iChild[0]->SetAndTestOP(0); |
|
221 iChild[0]->SetAndTestOP(-1,last); |
|
222 iChild[0]->SetAndTestOP(-1000,last); |
|
223 iChild[0]->SetAndTestOP(2); |
|
224 iChild[0]->SetAndTestOP(-1000,last); |
|
225 iChild[0]->SetAndTestOP(0); |
|
226 for(TInt index=0;index<=5;index++) |
|
227 iChild[4]->SetAndTestOP(index,index); |
|
228 iChild[0]->SetAndTestOP(-1,last); |
|
229 iChild[1]->SetAndTestOP(-1,last); |
|
230 iChild[2]->SetAndTestOP(-1,last); |
|
231 iChild[3]->SetAndTestOP(-1,last); |
|
232 iChild[4]->SetAndTestOP(-1,last); |
|
233 iChild[5]->SetAndTestOP(-1,last); |
|
234 TInt child; |
|
235 for (child=0;child<ENumChildren-1;++child) |
|
236 TestWindowOrderNext(child,child+1); |
|
237 TestWindowOrderNext(5); |
|
238 } |
|
239 |
|
240 void CTOrdinal::OrdinalPriority() |
|
241 { |
|
242 TBool retVal; |
|
243 TInt last12=iChild[2]->SetToLastAndGetOPPri(12); |
|
244 iChild[2]->TestOP(last12); |
|
245 TInt lastKMax=iChild[2]->SetToLastAndGetOPPri(KMaxTInt32); |
|
246 iChild[2]->TestOP(lastKMax); |
|
247 TInt last=iChild[2]->SetToLastAndGetOPPri(0); |
|
248 iChild[2]->TestOP(last); |
|
249 iChild[2]->SetAndTestOPPri(-1,12,last12); // One and only pri 12 window |
|
250 iChild[3]->SetAndTestOPPri(-1,KMaxTInt32,lastKMax); // One and only pri KMaxTInt32 window |
|
251 iChild[1]->SetAndTestOPPri(0,KMaxTInt32); |
|
252 iChild[5]->SetAndTestOP(-1,last-3); |
|
253 iChild[1]->TestOP(0); |
|
254 iChild[0]->SetAndTestOPPri(0,50); |
|
255 iChild[1]->SetAndTestOPPri(0,50); |
|
256 iChild[2]->SetAndTestOPPri(0,50); |
|
257 iChild[3]->SetAndTestOPPri(0,50); |
|
258 iChild[1]->TestOP(2); |
|
259 if (iGroupTest) |
|
260 { |
|
261 retVal=(reinterpret_cast<CBase*>(iChild[0]->NextSibling())==iClient->iGroup); |
|
262 TEST(retVal); |
|
263 if (!retVal) |
|
264 { |
|
265 _LIT(KLog,"iChild0 NextSibling is not the main group window"); |
|
266 LOG_MESSAGE(KLog); |
|
267 } |
|
268 retVal=(reinterpret_cast<CBase*>(iClient->iGroup->NextSibling())==iChild[4]); |
|
269 TEST(retVal); |
|
270 if (!retVal) |
|
271 { |
|
272 _LIT(KLog,"NextSibling of main group window is not iChild4"); |
|
273 LOG_MESSAGE(KLog); |
|
274 } |
|
275 } |
|
276 else |
|
277 TestWindowOrderNext(0,4); |
|
278 TestWindowOrderNext(4,5); |
|
279 TestWindowOrderNext(5); |
|
280 iChild[2]->SetAndTestOPPri(5,-1,0); |
|
281 iChild[3]->SetAndTestOPPri(5,-1,1); |
|
282 TestWindowOrderNext(5,2); |
|
283 iChild[0]->SetAndTestOPPri(100000,KMinTInt32,0); |
|
284 iChild[1]->SetAndTestOPPri(200000,KMinTInt32,1); |
|
285 iChild[2]->SetAndTestOPPri(300000,KMinTInt32,2); |
|
286 iChild[5]->SetAndTestOPPri(0,0,0); |
|
287 iChild[3]->TestOP(0); |
|
288 iChild[0]->SetAndTestOPPri(0,-1); |
|
289 iChild[1]->SetAndTestOPPri(0,-1); |
|
290 iChild[2]->SetAndTestOPPri(0,-1); |
|
291 iChild[3]->SetAndTestOPPri(0,1); |
|
292 iChild[4]->SetAndTestOPPri(0,1); |
|
293 iChild[5]->SetAndTestOPPri(0,1); |
|
294 TestWindowOrderPrev(0,1); |
|
295 TestWindowOrderPrev(1,2); |
|
296 if (iGroupTest) |
|
297 { |
|
298 retVal=(reinterpret_cast<CBase*>(iChild[2]->PrevSibling())==iClient->iGroup); |
|
299 TEST(retVal); |
|
300 if (!retVal) |
|
301 { |
|
302 _LIT(KLog,"iChild2 PrevSibling is not the main group window"); |
|
303 LOG_MESSAGE(KLog); |
|
304 } |
|
305 retVal=(reinterpret_cast<CBase*>(iClient->iGroup->PrevSibling())==iChild[3]); |
|
306 TEST(retVal); |
|
307 if (!retVal) |
|
308 { |
|
309 _LIT(KLog,"PrevSibling of main group window is not iChild3"); |
|
310 LOG_MESSAGE(KLog); |
|
311 } |
|
312 } |
|
313 else |
|
314 TestWindowOrderPrev(2,3); |
|
315 TestWindowOrderPrev(3,4); |
|
316 TestWindowOrderPrev(4,5); |
|
317 TestWindowOrderPrev(5); |
|
318 } |
|
319 |
|
320 void CTOrdinal::ConstructL() |
|
321 { |
|
322 iClient=new(ELeave) COrdinalClient(); |
|
323 iClient->SetScreenNumber(iTest->iScreenNumber); |
|
324 iClient->ConstructL(); |
|
325 } |
|
326 |
|
327 /** |
|
328 @SYMTestCaseID GRAPHICS-WSERV-0446 |
|
329 |
|
330 @SYMCR CR1164 |
|
331 |
|
332 @SYMTestCaseDesc Test ClientHandle function returns right value |
|
333 |
|
334 @SYMTestPriority High |
|
335 |
|
336 @SYMTestStatus Implemented |
|
337 |
|
338 @SYMTestActions Call this function on windows at various times |
|
339 |
|
340 @SYMTestExpectedResults The value set when window was created is returned |
|
341 */ |
|
342 void CTOrdinal::CreateWindowsL(TInt aMode) |
|
343 { |
|
344 RWindowTreeNode* parent=NULL; |
|
345 RWindowTreeNode* base=iClient->iGroup->WinTreeNode(); |
|
346 TInt errors=0; |
|
347 |
|
348 if (base->Child()!=0) |
|
349 { |
|
350 _LIT(KErrText,"Main Group Window has children at start of test"); |
|
351 LOG_MESSAGE(KErrText); |
|
352 AutoPanic(EAutoPanicGroupWinHasChild); |
|
353 } |
|
354 if (base->ClientHandle()!=reinterpret_cast<TUint32&>(iClient->iGroup)) |
|
355 ++errors; |
|
356 if (base->Parent()!=0) |
|
357 ++errors; |
|
358 TEST(errors==0); |
|
359 if (errors>0) |
|
360 { |
|
361 _LIT(KErrText,"Handles of Main Group Window are not as expected"); |
|
362 LOG_MESSAGE2(KErrText,errors); |
|
363 } |
|
364 iGroupTest=EFalse; |
|
365 switch(aMode) |
|
366 { |
|
367 case 3: |
|
368 iParent=COrdinalWindow::NewL(iClient,base,iTest,iStep); |
|
369 parent=iParent->WinTreeNode(); |
|
370 CheckHandlesOnNewWindow(iClient->iGroup,iParent); |
|
371 break; |
|
372 case 1: |
|
373 parent=iClient->iGroup->WinTreeNode(); |
|
374 break; |
|
375 case 2: |
|
376 iParent=COrdinalWindow::NewL(iClient,base,iTest,iStep); |
|
377 CheckHandlesOnNewWindow(iClient->iGroup,iParent); |
|
378 iParent2=COrdinalWindow::NewL(iClient,iParent->WinTreeNode(),iTest,iStep); |
|
379 CheckHandlesOnNewWindow(iParent,iParent2); |
|
380 iParent3=COrdinalWindow::NewL(iClient,iParent2->WinTreeNode(),iTest,iStep); |
|
381 parent=iParent3->WinTreeNode(); |
|
382 CheckHandlesOnNewWindow(iParent2,iParent3); |
|
383 break; |
|
384 case 0: |
|
385 iGroupTest=ETrue; |
|
386 for (TInt child=ENumChildren-1;child>=0;--child) |
|
387 iChild[child]=COrdinalWindowGroup::NewL(iClient,iTest,iStep); |
|
388 CheckHandles(0); |
|
389 return; |
|
390 } |
|
391 for (TInt child=ENumChildren-1;child>=0;--child) |
|
392 { |
|
393 iChild[child]=COrdinalWindow::NewL(iClient,parent,iTest,iStep); |
|
394 if (iChild[child]->Handle()!=parent->Child()) |
|
395 ++errors; |
|
396 } |
|
397 TEST(errors==0); |
|
398 if (errors>0) |
|
399 { |
|
400 _LIT(KErrText,"%d windows were not the first child"); |
|
401 LOG_MESSAGE2(KErrText,errors); |
|
402 } |
|
403 CheckHandles(parent->ClientHandle()); |
|
404 } |
|
405 |
|
406 void CTOrdinal::CheckHandlesOnNewWindow(CTWindowGroup* aParent,COrdinalWindowBase* aWin) |
|
407 { |
|
408 TInt errors=0; |
|
409 if (aParent->WinTreeNode()->Child()!=aWin->Handle()) |
|
410 ++errors; |
|
411 if (aWin->WinTreeNode()->Parent()!=reinterpret_cast<TUint32&>(aParent)) |
|
412 ++errors; |
|
413 CheckHandlesOnNewWindow(errors,aWin); |
|
414 } |
|
415 |
|
416 void CTOrdinal::CheckHandlesOnNewWindow(COrdinalWindowBase* aParent,COrdinalWindowBase* aWin) |
|
417 { |
|
418 TInt errors=0; |
|
419 if (aParent->WinTreeNode()->Child()!=aWin->Handle()) |
|
420 ++errors; |
|
421 if (aWin->WinTreeNode()->Parent()!=aParent->Handle()) |
|
422 ++errors; |
|
423 CheckHandlesOnNewWindow(errors,aWin); |
|
424 } |
|
425 |
|
426 void CTOrdinal::CheckHandlesOnNewWindow(TInt aErrors,COrdinalWindowBase* aWin) |
|
427 { |
|
428 RWindowTreeNode* win=aWin->WinTreeNode(); |
|
429 if (win->ClientHandle()!=aWin->Handle()) |
|
430 ++aErrors; |
|
431 if (win->PrevSibling()!=0) |
|
432 ++aErrors; |
|
433 if (win->NextSibling()!=0) |
|
434 ++aErrors; |
|
435 if (win->Child()!=0) |
|
436 ++aErrors; |
|
437 TEST(aErrors==0); |
|
438 if (aErrors>0) |
|
439 { |
|
440 _LIT(KErrText,"%d errors in handles of newly created window"); |
|
441 LOG_MESSAGE2(KErrText,aErrors); |
|
442 } |
|
443 } |
|
444 |
|
445 void CTOrdinal::CheckHandles(TUint aParent) |
|
446 { |
|
447 TInt errors=0; |
|
448 TInt child; |
|
449 for (child=0;child<ENumChildren;++child) |
|
450 { |
|
451 if (iChild[child]->WinTreeNode()->ClientHandle()!=iChild[child]->Handle()) |
|
452 ++errors; |
|
453 } |
|
454 TEST(errors==0); |
|
455 if (errors>0) |
|
456 { |
|
457 _LIT(KErrText,"%d windows gave wrong client handle"); |
|
458 LOG_MESSAGE2(KErrText,errors); |
|
459 errors=0; |
|
460 } |
|
461 for (child=0;child<ENumChildren;++child) |
|
462 { |
|
463 if (iChild[child]->WinTreeNode()->Parent()!=aParent) |
|
464 ++errors; |
|
465 } |
|
466 TEST(errors==0); |
|
467 if (errors>0) |
|
468 { |
|
469 _LIT(KErrText,"%d children gave wrong parent handle"); |
|
470 LOG_MESSAGE2(KErrText,errors); |
|
471 errors=0; |
|
472 } |
|
473 for (child=1;child<ENumChildren;++child) |
|
474 { |
|
475 if (iChild[child-1]->WinTreeNode()->NextSibling()!=iChild[child]->Handle()) |
|
476 ++errors; |
|
477 } |
|
478 if (iChild[5]->WinTreeNode()->NextSibling()!=0 && !iGroupTest) |
|
479 ++errors; |
|
480 TEST(errors==0); |
|
481 if (errors>0) |
|
482 { |
|
483 _LIT(KErrText,"%d windows gave wrong next sibling handle"); |
|
484 LOG_MESSAGE2(KErrText,errors); |
|
485 errors=0; |
|
486 } |
|
487 if (iChild[0]->WinTreeNode()->PrevSibling()!=0 && !iGroupTest) |
|
488 ++errors; |
|
489 for (child=1;child<ENumChildren;++child) |
|
490 { |
|
491 if (iChild[child]->WinTreeNode()->PrevSibling()!=iChild[child-1]->Handle()) |
|
492 ++errors; |
|
493 } |
|
494 TEST(errors==0); |
|
495 if (errors>0) |
|
496 { |
|
497 _LIT(KErrText,"%d windows gave wrong prev sibling handle"); |
|
498 LOG_MESSAGE2(KErrText,errors); |
|
499 } |
|
500 } |
|
501 |
|
502 COrdinalClient::COrdinalClient() |
|
503 { |
|
504 } |
|
505 |
|
506 void COrdinalClient::ConstructL() |
|
507 { |
|
508 User::LeaveIfError(iWs.Connect()); |
|
509 // change to correct screen |
|
510 // |
|
511 iScreen = new (ELeave) CWsScreenDevice(iWs); |
|
512 User::LeaveIfError(iScreen->Construct(iScreenNumber)); |
|
513 |
|
514 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0,-2000000000); |
|
515 TheClient->iWs.Flush(); |
|
516 iGroup=new(ELeave) CTWindowGroup(this); |
|
517 iGroup->ConstructL(); |
|
518 } |
|
519 |
|
520 COrdinalClient::~COrdinalClient() |
|
521 { |
|
522 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0,0); |
|
523 } |
|
524 |
|
525 void COrdinalClient::KeyL(const TKeyEvent &,const TTime &) |
|
526 { |
|
527 } |
|
528 |
|
529 void CTOrdinal::RunTestCaseL(TInt /*aCurTestCase*/) |
|
530 { |
|
531 _LIT(KTest1,"Ordinal 1"); |
|
532 ((CTOrdinalStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); |
|
533 switch(++iTest->iState) |
|
534 { |
|
535 /** |
|
536 @SYMTestCaseID GRAPHICS-WSERV-0217 |
|
537 |
|
538 @SYMDEF DEF081259 |
|
539 |
|
540 @SYMTestCaseDesc Test ordinal position and priority changes on windows |
|
541 |
|
542 @SYMTestPriority High |
|
543 |
|
544 @SYMTestStatus Implemented |
|
545 |
|
546 @SYMTestActions Set different ordinal positions and priorities on a |
|
547 number of windows and check they have been set |
|
548 correctly |
|
549 |
|
550 @SYMTestExpectedResults The positions and priorities are set correctly |
|
551 */ |
|
552 case 1: |
|
553 ((CTOrdinalStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0217")); |
|
554 iTest->LogSubTest(KTest1); |
|
555 { |
|
556 for(TInt index=0;index<4;index++) |
|
557 { |
|
558 ((CTOrdinalStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0446")); |
|
559 CreateWindowsL(index); |
|
560 ((CTOrdinalStep*)iStep)->RecordTestResultL(); |
|
561 OrdinalPos(); |
|
562 OrdinalPriority(); |
|
563 DestroyWindows(); |
|
564 } |
|
565 } |
|
566 ((CTOrdinalStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0217")); |
|
567 if (!iStep->TestStepResult() == EPass) |
|
568 TEST(EFalse); |
|
569 break; |
|
570 default: |
|
571 ((CTOrdinalStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); |
|
572 ((CTOrdinalStep*)iStep)->CloseTMSGraphicsStep(); |
|
573 TestComplete(); |
|
574 break; |
|
575 }; |
|
576 ((CTOrdinalStep*)iStep)->RecordTestResultL(); |
|
577 } |
|
578 |
|
579 __WS_CONSTRUCT_STEP__(Ordinal) |