1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/test/tauto/twindowsizecache.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2940 @@
1.4 +// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// General window tests
1.18 +//
1.19 +//
1.20 +
1.21 +/**
1.22 + @file
1.23 + @test
1.24 + @internalComponent - Internal Symbian test code
1.25 +*/
1.26 +
1.27 +#include "twindowsizecache.h"
1.28 +
1.29 +CTWindowSizeCacheTest::CTWindowSizeCacheTest(CTestStep* aStep) : CTWsGraphicsBase(aStep)
1.30 + {}
1.31 +
1.32 +CTWindowSizeCacheTest::~CTWindowSizeCacheTest()
1.33 + {
1.34 + }
1.35 +
1.36 +void CTWindowSizeCacheTest::ConstructL()
1.37 + {}
1.38 +
1.39 +
1.40 +void CTWindowSizeCacheTest::TestCreateRWindowL(TSizeCacheStatus aEnableWindowSizeCache)
1.41 + {
1.42 + __UHEAP_MARK;
1.43 + // w* State Initial
1.44 + RWsSession rws;
1.45 + TInt err = rws.Connect();
1.46 + CleanupClosePushL(rws);
1.47 + TEST(KErrNone == err);
1.48 +
1.49 + if (ETestSizeCacheEnabled == aEnableWindowSizeCache)
1.50 + {
1.51 + rws.EnableWindowSizeCacheL();
1.52 + }
1.53 +
1.54 + RWindowGroup wg(rws);
1.55 + err = wg.Construct(0);
1.56 + CleanupClosePushL(wg);
1.57 + TEST(KErrNone == err);
1.58 +
1.59 + // w1 State 0
1.60 + RWindow w1(rws);
1.61 + err = w1.Construct(wg,1);
1.62 + CleanupClosePushL(w1);
1.63 + TEST(KErrNone == err);
1.64 +
1.65 + // w2 State 0
1.66 + RWindow w2(rws);
1.67 + err = w2.Construct(wg,2);
1.68 + CleanupClosePushL(w2);
1.69 + TEST(KErrNone == err);
1.70 +
1.71 + CleanupStack::Pop(2);
1.72 +
1.73 + // w1 State Final
1.74 + w1.Close();
1.75 + // w2 State Final
1.76 + w2.Close();
1.77 +
1.78 + RWindow w3(rws);
1.79 + // w3 State 0
1.80 + err = w3.Construct(wg,1);
1.81 + CleanupClosePushL(w3);
1.82 + TEST(KErrNone == err);
1.83 +
1.84 + CleanupStack::Pop(2);
1.85 +
1.86 + // w3 State Final
1.87 + w3.Close();
1.88 +
1.89 + wg.Close();
1.90 +
1.91 + RWindowGroup wg2(rws);
1.92 + err = wg2.Construct(0);
1.93 + CleanupClosePushL(wg2);
1.94 + TEST(KErrNone == err);
1.95 +
1.96 + RWindowGroup wg3(rws);
1.97 + err = wg3.Construct(1);
1.98 + CleanupClosePushL(wg3);
1.99 + TEST(KErrNone == err);
1.100 +
1.101 + // w4 State 0
1.102 + RWindow w4(rws);
1.103 + err = w4.Construct(wg2,2);
1.104 + CleanupClosePushL(w4);
1.105 + TEST(KErrNone == err);
1.106 +
1.107 + // w5 State 0
1.108 + RWindow w5(rws);
1.109 + err = w5.Construct(wg3,3);
1.110 + CleanupClosePushL(w5);
1.111 + TEST(KErrNone == err);
1.112 +
1.113 + CleanupStack::Pop(5);
1.114 +
1.115 + // w4 State Final
1.116 + w4.Close();
1.117 +
1.118 + // w5 State Final
1.119 + // Check nothing bad happens when calling Close more than once on RWindow
1.120 + w5.Close();
1.121 + w5.Close();
1.122 +
1.123 + // Check nothing bad happens when calling Close more than once on RWindowGroup
1.124 + wg2.Close();
1.125 + wg2.Close();
1.126 +
1.127 + wg3.Close();
1.128 +
1.129 + // Check nothing bad happens when calling Close more than once on RWsSession
1.130 + rws.Close();
1.131 + rws.Close();
1.132 + __UHEAP_MARKEND;
1.133 + }
1.134 +
1.135 +void CTWindowSizeCacheTest::TestCreateRBlankWindowL(TSizeCacheStatus aEnableWindowSizeCache)
1.136 + {
1.137 + __UHEAP_MARK;
1.138 + // w* State Initial
1.139 + RWsSession rws;
1.140 + TInt err = rws.Connect();
1.141 + CleanupClosePushL(rws);
1.142 + TEST(KErrNone == err);
1.143 +
1.144 + if (ETestSizeCacheEnabled == aEnableWindowSizeCache)
1.145 + {
1.146 + rws.EnableWindowSizeCacheL();
1.147 + }
1.148 +
1.149 + RWindowGroup wg(rws);
1.150 + err = wg.Construct(0);
1.151 + CleanupClosePushL(wg);
1.152 + TEST(KErrNone == err);
1.153 +
1.154 + // w1 State 0
1.155 + RBlankWindow w1(rws);
1.156 + err = w1.Construct(wg,1);
1.157 + CleanupClosePushL(w1);
1.158 + TEST(KErrNone == err);
1.159 +
1.160 + // w2 State 0
1.161 + RBlankWindow w2(rws);
1.162 + err = w2.Construct(wg,2);
1.163 + CleanupClosePushL(w2);
1.164 + TEST(KErrNone == err);
1.165 +
1.166 + CleanupStack::Pop(2);
1.167 +
1.168 + // w1 State Final
1.169 + w1.Close();
1.170 + // w2 State Final
1.171 + w2.Close();
1.172 +
1.173 + RBlankWindow w3(rws);
1.174 + // w3 State 0
1.175 + err = w3.Construct(wg,1);
1.176 + CleanupClosePushL(w3);
1.177 + TEST(KErrNone == err);
1.178 +
1.179 + CleanupStack::Pop(2);
1.180 +
1.181 + // w3 State Final
1.182 + w3.Close();
1.183 +
1.184 + wg.Close();
1.185 +
1.186 + RWindowGroup wg2(rws);
1.187 + err = wg2.Construct(0);
1.188 + CleanupClosePushL(wg2);
1.189 + TEST(KErrNone == err);
1.190 +
1.191 + RWindowGroup wg3(rws);
1.192 + err = wg3.Construct(1);
1.193 + CleanupClosePushL(wg3);
1.194 + TEST(KErrNone == err);
1.195 +
1.196 + // w4 State 0
1.197 + RBlankWindow w4(rws);
1.198 + err = w4.Construct(wg2,2);
1.199 + CleanupClosePushL(w4);
1.200 + TEST(KErrNone == err);
1.201 +
1.202 + // w5 State 0
1.203 + RBlankWindow w5(rws);
1.204 + err = w5.Construct(wg3,3);
1.205 + CleanupClosePushL(w5);
1.206 + TEST(KErrNone == err);
1.207 +
1.208 + CleanupStack::Pop(5);
1.209 +
1.210 + // w4 State Final
1.211 + w4.Close();
1.212 +
1.213 + // w5 State Final
1.214 + // Check nothing bad happens when calling Close more than once on RBlankWindow
1.215 + w5.Close();
1.216 + w5.Close();
1.217 +
1.218 + wg2.Close();
1.219 + wg3.Close();
1.220 + rws.Close();
1.221 + __UHEAP_MARKEND;
1.222 + }
1.223 +
1.224 +void CTWindowSizeCacheTest::TestCreateRBackedUpWindowL(TSizeCacheStatus aEnableWindowSizeCache, TDisplayMode aDisplayMode)
1.225 + {
1.226 + __UHEAP_MARK;
1.227 + // w* State Initial
1.228 + RWsSession rws;
1.229 + TInt err = rws.Connect();
1.230 + CleanupClosePushL(rws);
1.231 + TEST(KErrNone == err);
1.232 +
1.233 + if (ETestSizeCacheEnabled == aEnableWindowSizeCache)
1.234 + {
1.235 + rws.EnableWindowSizeCacheL();
1.236 + }
1.237 +
1.238 + RWindowGroup wg(rws);
1.239 + err = wg.Construct(0);
1.240 + CleanupClosePushL(wg);
1.241 + TEST(KErrNone == err);
1.242 +
1.243 + // w1 State 0
1.244 + RBackedUpWindow w1(rws);
1.245 + err = w1.Construct(wg,aDisplayMode,1);
1.246 + CleanupClosePushL(w1);
1.247 + TEST(KErrNone == err);
1.248 +
1.249 + // w2 State 0
1.250 + RBackedUpWindow w2(rws);
1.251 + err = w2.Construct(wg,aDisplayMode,2);
1.252 + CleanupClosePushL(w2);
1.253 + TEST(KErrNone == err);
1.254 +
1.255 + CleanupStack::Pop(2);
1.256 +
1.257 + // w1 State Final
1.258 + w1.Close();
1.259 +
1.260 + // w2 State Final
1.261 + w2.Close();
1.262 +
1.263 + RBackedUpWindow w3(rws);
1.264 + // w3 State 0
1.265 + err = w3.Construct(wg,aDisplayMode,1);
1.266 + CleanupClosePushL(w3);
1.267 + TEST(KErrNone == err);
1.268 +
1.269 + CleanupStack::Pop(2);
1.270 +
1.271 + // w3 State Final
1.272 + w3.Close();
1.273 +
1.274 + wg.Close();
1.275 +
1.276 + RWindowGroup wg2(rws);
1.277 + CleanupClosePushL(wg2);
1.278 + err = wg2.Construct(0);
1.279 + TEST(KErrNone == err);
1.280 +
1.281 + RWindowGroup wg3(rws);
1.282 + err = wg3.Construct(1);
1.283 + CleanupClosePushL(wg3);
1.284 + TEST(KErrNone == err);
1.285 +
1.286 + // w4 State 0
1.287 + RBackedUpWindow w4(rws);
1.288 + err = w4.Construct(wg2,aDisplayMode,2);
1.289 + CleanupClosePushL(w4);
1.290 + TEST(KErrNone == err);
1.291 +
1.292 + // w5 State 0
1.293 + RBackedUpWindow w5(rws);
1.294 + err = w5.Construct(wg3,aDisplayMode,3);
1.295 + CleanupClosePushL(w5);
1.296 + TEST(KErrNone == err);
1.297 +
1.298 + CleanupStack::Pop(5);
1.299 +
1.300 + // w4 State Final
1.301 + w4.Close();
1.302 +
1.303 + // w5 State Final
1.304 + // Check nothing bad happens when calling Close more than once on RBackedUpWindow
1.305 + w5.Close();
1.306 + w5.Close();
1.307 +
1.308 + wg2.Close();
1.309 + wg3.Close();
1.310 + rws.Close();
1.311 + __UHEAP_MARKEND;
1.312 + }
1.313 +
1.314 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntryL(TSizeCacheStatus aEnableWindowSizeCache)
1.315 + {
1.316 + __UHEAP_MARK;
1.317 + // w* State Initial
1.318 + RWsSession rws;
1.319 + TInt err = rws.Connect();
1.320 + CleanupClosePushL(rws);
1.321 + TEST(err==KErrNone);
1.322 +
1.323 + if (aEnableWindowSizeCache)
1.324 + {
1.325 + rws.EnableWindowSizeCacheL();
1.326 + }
1.327 +
1.328 + RWindowGroup wg(rws);
1.329 + wg.Construct(0);
1.330 + CleanupClosePushL(rws);
1.331 +
1.332 + // w1 State 0
1.333 + RWindow w1(rws);
1.334 + w1.Construct(wg,1);
1.335 + CleanupClosePushL(w1);
1.336 +
1.337 + // w1 State Final
1.338 + CleanupStack::Pop();
1.339 + w1.Close();
1.340 +
1.341 + CleanupStack::Pop();
1.342 + wg.Close();
1.343 +
1.344 + CleanupStack::Pop();
1.345 + rws.Close();
1.346 +
1.347 + __UHEAP_MARKEND;
1.348 + }
1.349 +
1.350 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.351 + {
1.352 + __UHEAP_MARK;
1.353 + // w* State Initial
1.354 + RWsSession rws;
1.355 + TInt err = rws.Connect();
1.356 + CleanupClosePushL(rws);
1.357 + TEST(err==KErrNone);
1.358 +
1.359 + if (aEnableWindowSizeCache)
1.360 + {
1.361 + rws.EnableWindowSizeCacheL();
1.362 + }
1.363 +
1.364 + RWindowGroup wg(rws);
1.365 + wg.Construct(0);
1.366 + CleanupClosePushL(rws);
1.367 +
1.368 + // w1 State 0
1.369 + RWindow w1(rws);
1.370 + w1.Construct(wg,1);
1.371 + CleanupClosePushL(w1);
1.372 +
1.373 + // w1 State 0
1.374 + TPoint point1 (10101,897);
1.375 + TSize size1 (10001,123);
1.376 + err = w1.SetExtentErr(point1, size1);
1.377 + TEST(KErrNone == err);
1.378 +
1.379 + // w1 State Final
1.380 + CleanupStack::Pop();
1.381 + w1.Close();
1.382 +
1.383 + CleanupStack::Pop();
1.384 + wg.Close();
1.385 +
1.386 + CleanupStack::Pop();
1.387 + rws.Close();
1.388 +
1.389 + __UHEAP_MARKEND;
1.390 + }
1.391 +
1.392 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.393 + {
1.394 + __UHEAP_MARK;
1.395 + // w* State Initial
1.396 + RWsSession rws;
1.397 + TInt err = rws.Connect();
1.398 + CleanupClosePushL(rws);
1.399 + TEST(err==KErrNone);
1.400 +
1.401 + if (aEnableWindowSizeCache)
1.402 + {
1.403 + rws.EnableWindowSizeCacheL();
1.404 + }
1.405 +
1.406 + RWindowGroup wg(rws);
1.407 + wg.Construct(0);
1.408 + CleanupClosePushL(rws);
1.409 +
1.410 + // w1 State 0
1.411 + RWindow w1(rws);
1.412 + w1.Construct(wg,1);
1.413 + CleanupClosePushL(w1);
1.414 +
1.415 + // w1 State 0
1.416 + TSize size1 (10001,123);
1.417 + err = w1.SetSizeErr(size1);
1.418 + TEST(KErrNone == err);
1.419 +
1.420 + // w1 State Final
1.421 + CleanupStack::Pop();
1.422 + w1.Close();
1.423 +
1.424 + CleanupStack::Pop();
1.425 + wg.Close();
1.426 +
1.427 + CleanupStack::Pop();
1.428 + rws.Close();
1.429 +
1.430 + __UHEAP_MARKEND;
1.431 + }
1.432 +
1.433 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.434 + {
1.435 + __UHEAP_MARK;
1.436 + // w* State Initial
1.437 + RWsSession rws;
1.438 + TInt err = rws.Connect();
1.439 + CleanupClosePushL(rws);
1.440 + TEST(err==KErrNone);
1.441 +
1.442 + if (aEnableWindowSizeCache)
1.443 + {
1.444 + rws.EnableWindowSizeCacheL();
1.445 + }
1.446 +
1.447 + RWindowGroup wg(rws);
1.448 + wg.Construct(0);
1.449 + CleanupClosePushL(rws);
1.450 +
1.451 + // w1 State 0
1.452 + RWindow w1(rws);
1.453 + w1.Construct(wg,1);
1.454 + CleanupClosePushL(w1);
1.455 +
1.456 + // w1 State 0
1.457 + TPoint point1 (10101,897);
1.458 + TSize size1 (10001,123);
1.459 + w1.SetExtent(point1, size1);
1.460 + rws.Flush();
1.461 +
1.462 + // w1 State Final
1.463 + CleanupStack::Pop();
1.464 + w1.Close();
1.465 +
1.466 + CleanupStack::Pop();
1.467 + wg.Close();
1.468 +
1.469 + CleanupStack::Pop();
1.470 + rws.Close();
1.471 +
1.472 + __UHEAP_MARKEND;
1.473 + }
1.474 +
1.475 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)
1.476 + {
1.477 + __UHEAP_MARK;
1.478 + // w* State Initial
1.479 + RWsSession rws;
1.480 + TInt err = rws.Connect();
1.481 + CleanupClosePushL(rws);
1.482 + TEST(err==KErrNone);
1.483 +
1.484 + if (aEnableWindowSizeCache)
1.485 + {
1.486 + rws.EnableWindowSizeCacheL();
1.487 + }
1.488 +
1.489 + RWindowGroup wg(rws);
1.490 + wg.Construct(0);
1.491 + CleanupClosePushL(rws);
1.492 +
1.493 + // w1 State 0
1.494 + RWindow w1(rws);
1.495 + w1.Construct(wg,1);
1.496 + CleanupClosePushL(w1);
1.497 +
1.498 + // w1 State 0
1.499 + TSize size1 (10001,123);
1.500 + w1.SetSize(size1);
1.501 + rws.Flush();
1.502 +
1.503 + // w1 State Final
1.504 + CleanupStack::Pop();
1.505 + w1.Close();
1.506 +
1.507 + CleanupStack::Pop();
1.508 + wg.Close();
1.509 +
1.510 + CleanupStack::Pop();
1.511 + rws.Close();
1.512 +
1.513 + __UHEAP_MARKEND;
1.514 + }
1.515 +
1.516 +void CTWindowSizeCacheTest::TestRWindowNoCacheEntryEnableWindowSizeCacheL()
1.517 + {
1.518 + __UHEAP_MARK;
1.519 + // w* State Initial
1.520 + RWsSession rws;
1.521 + TInt err = rws.Connect();
1.522 + CleanupClosePushL(rws);
1.523 + TEST(err==KErrNone);
1.524 +
1.525 + rws.EnableWindowSizeCacheL();
1.526 +
1.527 + RWindowGroup wg(rws);
1.528 + wg.Construct(0);
1.529 + CleanupClosePushL(rws);
1.530 +
1.531 + // w1 State 0
1.532 + RWindow w1(rws);
1.533 + w1.Construct(wg,1);
1.534 + CleanupClosePushL(w1);
1.535 +
1.536 + // w1 State 0
1.537 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.538 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.539 + rws.EnableWindowSizeCacheL();
1.540 +
1.541 + // w1 State Final
1.542 + CleanupStack::Pop();
1.543 + w1.Close();
1.544 +
1.545 + CleanupStack::Pop();
1.546 + wg.Close();
1.547 +
1.548 + CleanupStack::Pop();
1.549 + rws.Close();
1.550 +
1.551 + __UHEAP_MARKEND;
1.552 + }
1.553 +
1.554 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanL(TSizeCacheStatus aEnableWindowSizeCache)
1.555 + {
1.556 + __UHEAP_MARK;
1.557 + // w* State Initial
1.558 + RWsSession rws;
1.559 + TInt err = rws.Connect();
1.560 + CleanupClosePushL(rws);
1.561 + TEST(err==KErrNone);
1.562 +
1.563 + if (aEnableWindowSizeCache)
1.564 + {
1.565 + rws.EnableWindowSizeCacheL();
1.566 + }
1.567 +
1.568 + RWindowGroup wg(rws);
1.569 + wg.Construct(0);
1.570 + CleanupClosePushL(rws);
1.571 +
1.572 + // w1 State 0
1.573 + RWindow w1(rws);
1.574 + w1.Construct(wg,1);
1.575 + CleanupClosePushL(w1);
1.576 +
1.577 + // w1 State 0
1.578 + TSize size1 (10001,123);
1.579 + w1.SetSize(size1);
1.580 + rws.Flush();
1.581 +
1.582 + // w1 State 1
1.583 + TSize retSize1 = w1.Size();
1.584 + TEST(retSize1 == size1);
1.585 +
1.586 + // w1 State Final
1.587 + CleanupStack::Pop();
1.588 + w1.Close();
1.589 +
1.590 + CleanupStack::Pop();
1.591 + wg.Close();
1.592 +
1.593 + CleanupStack::Pop();
1.594 + rws.Close();
1.595 +
1.596 + __UHEAP_MARKEND;
1.597 + }
1.598 +
1.599 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanSizeL(TSizeCacheStatus aEnableWindowSizeCache)
1.600 + {
1.601 + __UHEAP_MARK;
1.602 + // w* State Initial
1.603 + RWsSession rws;
1.604 + TInt err = rws.Connect();
1.605 + CleanupClosePushL(rws);
1.606 + TEST(err==KErrNone);
1.607 +
1.608 + if (aEnableWindowSizeCache)
1.609 + {
1.610 + rws.EnableWindowSizeCacheL();
1.611 + }
1.612 +
1.613 + RWindowGroup wg(rws);
1.614 + wg.Construct(0);
1.615 + CleanupClosePushL(rws);
1.616 +
1.617 + // w1 State 0
1.618 + RWindow w1(rws);
1.619 + w1.Construct(wg,1);
1.620 + CleanupClosePushL(w1);
1.621 +
1.622 + // w1 State 0
1.623 + TSize size1 (10001,123);
1.624 + w1.SetSize(size1);
1.625 + rws.Flush();
1.626 +
1.627 + // w1 State 1
1.628 + TSize retSize1 = w1.Size();
1.629 + TEST(retSize1 == size1);
1.630 +
1.631 + // w1 State 1
1.632 + TSize retSize2 = w1.Size();
1.633 + TEST(retSize2 == size1);
1.634 +
1.635 + // w1 State Final
1.636 + CleanupStack::Pop();
1.637 + w1.Close();
1.638 +
1.639 + CleanupStack::Pop();
1.640 + wg.Close();
1.641 +
1.642 + CleanupStack::Pop();
1.643 + rws.Close();
1.644 +
1.645 + __UHEAP_MARKEND;
1.646 + }
1.647 +
1.648 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheL()
1.649 + {
1.650 + __UHEAP_MARK;
1.651 + // w* State Initial
1.652 + RWsSession rws;
1.653 + TInt err = rws.Connect();
1.654 + CleanupClosePushL(rws);
1.655 + TEST(err==KErrNone);
1.656 +
1.657 + rws.EnableWindowSizeCacheL();
1.658 +
1.659 + RWindowGroup wg(rws);
1.660 + wg.Construct(0);
1.661 + CleanupClosePushL(rws);
1.662 +
1.663 + // w1 State 0
1.664 + RWindow w1(rws);
1.665 + w1.Construct(wg,1);
1.666 + CleanupClosePushL(w1);
1.667 +
1.668 + // w1 State 0
1.669 + TSize size1 (10001,123);
1.670 + w1.SetSize(size1);
1.671 + rws.Flush();
1.672 +
1.673 + // w1 State 1
1.674 + TSize retSize1 = w1.Size();
1.675 + TEST(retSize1 == size1);
1.676 +
1.677 + // w1 State 1
1.678 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.679 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.680 + rws.EnableWindowSizeCacheL();
1.681 +
1.682 + // w1 State Final
1.683 + CleanupStack::Pop();
1.684 + w1.Close();
1.685 +
1.686 + CleanupStack::Pop();
1.687 + wg.Close();
1.688 +
1.689 + CleanupStack::Pop();
1.690 + rws.Close();
1.691 +
1.692 + __UHEAP_MARKEND;
1.693 + }
1.694 +
1.695 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheLSizeL()
1.696 + {
1.697 + __UHEAP_MARK;
1.698 + // w* State Initial
1.699 + RWsSession rws;
1.700 + TInt err = rws.Connect();
1.701 + CleanupClosePushL(rws);
1.702 + TEST(err==KErrNone);
1.703 +
1.704 + rws.EnableWindowSizeCacheL();
1.705 +
1.706 + RWindowGroup wg(rws);
1.707 + wg.Construct(0);
1.708 + CleanupClosePushL(rws);
1.709 +
1.710 + // w1 State 0
1.711 + RWindow w1(rws);
1.712 + w1.Construct(wg,1);
1.713 + CleanupClosePushL(w1);
1.714 +
1.715 + // w1 State 0
1.716 + TSize size1 (10001,123);
1.717 + w1.SetSize(size1);
1.718 + rws.Flush();
1.719 +
1.720 + // w1 State 1
1.721 + TSize retSize1 = w1.Size();
1.722 + TEST(retSize1 == size1);
1.723 +
1.724 + // w1 State 1
1.725 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.726 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.727 + rws.EnableWindowSizeCacheL();
1.728 +
1.729 + // w1 State 1
1.730 + TSize retSize2 = w1.Size();
1.731 + TEST(retSize2 == size1);
1.732 +
1.733 + // w1 State Final
1.734 + CleanupStack::Pop();
1.735 + w1.Close();
1.736 +
1.737 + CleanupStack::Pop();
1.738 + wg.Close();
1.739 +
1.740 + CleanupStack::Pop();
1.741 + rws.Close();
1.742 +
1.743 + __UHEAP_MARKEND;
1.744 + }
1.745 +
1.746 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)
1.747 + {
1.748 + __UHEAP_MARK;
1.749 + // w* State Initial
1.750 + RWsSession rws;
1.751 + TInt err = rws.Connect();
1.752 + CleanupClosePushL(rws);
1.753 + TEST(err==KErrNone);
1.754 +
1.755 + if (aEnableWindowSizeCache)
1.756 + {
1.757 + rws.EnableWindowSizeCacheL();
1.758 + }
1.759 +
1.760 + RWindowGroup wg(rws);
1.761 + wg.Construct(0);
1.762 + CleanupClosePushL(rws);
1.763 +
1.764 + // w1 State 0
1.765 + RWindow w1(rws);
1.766 + w1.Construct(wg,1);
1.767 + CleanupClosePushL(w1);
1.768 +
1.769 + // w1 State 0
1.770 + TSize size1 (10001,123);
1.771 + w1.SetSize(size1);
1.772 + rws.Flush();
1.773 +
1.774 + // w1 State 1
1.775 + TSize retSize1 = w1.Size();
1.776 + TEST(retSize1 == size1);
1.777 +
1.778 + // w1 State 2
1.779 + TSize size2 (20002,223);
1.780 + w1.SetSize(size2);
1.781 + rws.Flush();
1.782 +
1.783 + // w1 State Final
1.784 + CleanupStack::Pop();
1.785 + w1.Close();
1.786 +
1.787 + CleanupStack::Pop();
1.788 + wg.Close();
1.789 +
1.790 + CleanupStack::Pop();
1.791 + rws.Close();
1.792 +
1.793 + __UHEAP_MARKEND;
1.794 + }
1.795 +
1.796 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.797 + {
1.798 + __UHEAP_MARK;
1.799 + // w* State Initial
1.800 + RWsSession rws;
1.801 + TInt err = rws.Connect();
1.802 + CleanupClosePushL(rws);
1.803 + TEST(err==KErrNone);
1.804 +
1.805 + if (aEnableWindowSizeCache)
1.806 + {
1.807 + rws.EnableWindowSizeCacheL();
1.808 + }
1.809 +
1.810 + RWindowGroup wg(rws);
1.811 + wg.Construct(0);
1.812 + CleanupClosePushL(rws);
1.813 +
1.814 + // w1 State 0
1.815 + RWindow w1(rws);
1.816 + w1.Construct(wg,1);
1.817 + CleanupClosePushL(w1);
1.818 +
1.819 + // w1 State 0
1.820 + TSize size1 (10001,123);
1.821 + w1.SetSize(size1);
1.822 + rws.Flush();
1.823 +
1.824 + // w1 State 1
1.825 + TSize retSize1 = w1.Size();
1.826 + TEST(retSize1 == size1);
1.827 +
1.828 + // w1 State 2
1.829 + TPoint point2 (20202,223);
1.830 + TSize size2 (20002,223);
1.831 + w1.SetExtent(point2, size2);
1.832 + rws.Flush();
1.833 +
1.834 + // w1 State Final
1.835 + CleanupStack::Pop();
1.836 + w1.Close();
1.837 +
1.838 + CleanupStack::Pop();
1.839 + wg.Close();
1.840 +
1.841 + CleanupStack::Pop();
1.842 + rws.Close();
1.843 +
1.844 + __UHEAP_MARKEND;
1.845 + }
1.846 +
1.847 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.848 + {
1.849 + __UHEAP_MARK;
1.850 + // w* State Initial
1.851 + RWsSession rws;
1.852 + TInt err = rws.Connect();
1.853 + CleanupClosePushL(rws);
1.854 + TEST(err==KErrNone);
1.855 +
1.856 + if (aEnableWindowSizeCache)
1.857 + {
1.858 + rws.EnableWindowSizeCacheL();
1.859 + }
1.860 +
1.861 + RWindowGroup wg(rws);
1.862 + wg.Construct(0);
1.863 + CleanupClosePushL(rws);
1.864 +
1.865 + // w1 State 0
1.866 + RWindow w1(rws);
1.867 + w1.Construct(wg,1);
1.868 + CleanupClosePushL(w1);
1.869 +
1.870 + // w1 State 0
1.871 + TSize size1 (10001,123);
1.872 + w1.SetSize(size1);
1.873 + rws.Flush();
1.874 +
1.875 + // w1 State 1
1.876 + TSize retSize1 = w1.Size();
1.877 + TEST(retSize1 == size1);
1.878 +
1.879 + // w1 State 2
1.880 + TSize size2 (20002,223);
1.881 + err = w1.SetSizeErr(size2);
1.882 + TEST(KErrNone == err);
1.883 +
1.884 + // w1 State Final
1.885 + CleanupStack::Pop();
1.886 + w1.Close();
1.887 +
1.888 + CleanupStack::Pop();
1.889 + wg.Close();
1.890 +
1.891 + CleanupStack::Pop();
1.892 + rws.Close();
1.893 +
1.894 + __UHEAP_MARKEND;
1.895 + }
1.896 +
1.897 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.898 + {
1.899 + __UHEAP_MARK;
1.900 + // w* State Initial
1.901 + RWsSession rws;
1.902 + TInt err = rws.Connect();
1.903 + CleanupClosePushL(rws);
1.904 + TEST(err==KErrNone);
1.905 +
1.906 + if (aEnableWindowSizeCache)
1.907 + {
1.908 + rws.EnableWindowSizeCacheL();
1.909 + }
1.910 +
1.911 + RWindowGroup wg(rws);
1.912 + wg.Construct(0);
1.913 + CleanupClosePushL(rws);
1.914 +
1.915 + // w1 State 0
1.916 + RWindow w1(rws);
1.917 + w1.Construct(wg,1);
1.918 + CleanupClosePushL(w1);
1.919 +
1.920 + // w1 State 0
1.921 + TSize size1 (10001,123);
1.922 + w1.SetSize(size1);
1.923 + rws.Flush();
1.924 +
1.925 + // w1 State 1
1.926 + TSize retSize1 = w1.Size();
1.927 + TEST(retSize1 == size1);
1.928 +
1.929 + // w1 State 2
1.930 + TPoint point2 (20202,223);
1.931 + TSize size2 (20002,223);
1.932 + err = w1.SetExtentErr(point2, size2);
1.933 + TEST(KErrNone == err);
1.934 +
1.935 + // w1 State Final
1.936 + CleanupStack::Pop();
1.937 + w1.Close();
1.938 +
1.939 + CleanupStack::Pop();
1.940 + wg.Close();
1.941 +
1.942 + CleanupStack::Pop();
1.943 + rws.Close();
1.944 +
1.945 + __UHEAP_MARKEND;
1.946 + }
1.947 +
1.948 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(TSizeCacheStatus aEnableWindowSizeCache)
1.949 + {
1.950 + __UHEAP_MARK;
1.951 + // w* State Initial
1.952 + RWsSession rws;
1.953 + TInt err = rws.Connect();
1.954 + CleanupClosePushL(rws);
1.955 + TEST(err==KErrNone);
1.956 +
1.957 + if (aEnableWindowSizeCache)
1.958 + {
1.959 + rws.EnableWindowSizeCacheL();
1.960 + }
1.961 +
1.962 + RWindowGroup wg(rws);
1.963 + wg.Construct(0);
1.964 + CleanupClosePushL(rws);
1.965 +
1.966 + // w1 State 0
1.967 + RWindow w1(rws);
1.968 + w1.Construct(wg,1);
1.969 + CleanupClosePushL(w1);
1.970 +
1.971 + // w1 State 0
1.972 + TSize size1 (10001,123);
1.973 + w1.SetSize(size1);
1.974 + rws.Flush();
1.975 +
1.976 + // w1 State 1
1.977 + TSize retSize1 = w1.Size();
1.978 + TEST(retSize1 == size1);
1.979 +
1.980 + // w1 State 2
1.981 + TSize size2 (20002,223);
1.982 + w1.SetSize(size2);
1.983 +
1.984 + TSize size3 (30003,323);
1.985 + // w1 State 2
1.986 + w1.SetSize(size3);
1.987 + rws.Flush();
1.988 +
1.989 + // w1 State Final
1.990 + CleanupStack::Pop();
1.991 + w1.Close();
1.992 +
1.993 + CleanupStack::Pop();
1.994 + wg.Close();
1.995 +
1.996 + CleanupStack::Pop();
1.997 + rws.Close();
1.998 +
1.999 + __UHEAP_MARKEND;
1.1000 + }
1.1001 +
1.1002 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.1003 + {
1.1004 + __UHEAP_MARK;
1.1005 + // w* State Initial
1.1006 + RWsSession rws;
1.1007 + TInt err = rws.Connect();
1.1008 + CleanupClosePushL(rws);
1.1009 + TEST(err==KErrNone);
1.1010 +
1.1011 + if (aEnableWindowSizeCache)
1.1012 + {
1.1013 + rws.EnableWindowSizeCacheL();
1.1014 + }
1.1015 +
1.1016 + RWindowGroup wg(rws);
1.1017 + wg.Construct(0);
1.1018 + CleanupClosePushL(rws);
1.1019 +
1.1020 + // w1 State 0
1.1021 + RWindow w1(rws);
1.1022 + w1.Construct(wg,1);
1.1023 + CleanupClosePushL(w1);
1.1024 +
1.1025 + // w1 State 0
1.1026 + TSize size1 (10001,123);
1.1027 + w1.SetSize(size1);
1.1028 + rws.Flush();
1.1029 +
1.1030 + // w1 State 1
1.1031 + TSize retSize1 = w1.Size();
1.1032 + TEST(retSize1 == size1);
1.1033 +
1.1034 + // w1 State 2
1.1035 + TSize size2 (20002,223);
1.1036 + w1.SetSize(size2);
1.1037 +
1.1038 + // w1 State 2
1.1039 + TPoint point3 (30303,232);
1.1040 + TSize size3 (30003,323);
1.1041 + w1.SetExtent(point3, size3);
1.1042 + rws.Flush();
1.1043 +
1.1044 + // w1 State Final
1.1045 + CleanupStack::Pop();
1.1046 + w1.Close();
1.1047 +
1.1048 + CleanupStack::Pop();
1.1049 + wg.Close();
1.1050 +
1.1051 + CleanupStack::Pop();
1.1052 + rws.Close();
1.1053 +
1.1054 + __UHEAP_MARKEND;
1.1055 + }
1.1056 +
1.1057 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1058 + {
1.1059 + __UHEAP_MARK;
1.1060 + // w* State Initial
1.1061 + RWsSession rws;
1.1062 + TInt err = rws.Connect();
1.1063 + CleanupClosePushL(rws);
1.1064 + TEST(err==KErrNone);
1.1065 +
1.1066 + if (aEnableWindowSizeCache)
1.1067 + {
1.1068 + rws.EnableWindowSizeCacheL();
1.1069 + }
1.1070 +
1.1071 + RWindowGroup wg(rws);
1.1072 + wg.Construct(0);
1.1073 + CleanupClosePushL(rws);
1.1074 +
1.1075 + // w1 State 0
1.1076 + RWindow w1(rws);
1.1077 + w1.Construct(wg,1);
1.1078 + CleanupClosePushL(w1);
1.1079 +
1.1080 + // w1 State 0
1.1081 + TSize size1 (10001,123);
1.1082 + w1.SetSize(size1);
1.1083 + rws.Flush();
1.1084 +
1.1085 + // w1 State 1
1.1086 + TSize retSize1 = w1.Size();
1.1087 + TEST(retSize1 == size1);
1.1088 +
1.1089 + // w1 State 2
1.1090 + TSize size2 (20002,223);
1.1091 + w1.SetSize(size2);
1.1092 +
1.1093 + // w1 State 2
1.1094 + TSize size3 (30003,323);
1.1095 + err = w1.SetSizeErr(size3);
1.1096 + TEST(KErrNone == err);
1.1097 +
1.1098 + // w1 State Final
1.1099 + CleanupStack::Pop();
1.1100 + w1.Close();
1.1101 +
1.1102 + CleanupStack::Pop();
1.1103 + wg.Close();
1.1104 +
1.1105 + CleanupStack::Pop();
1.1106 + rws.Close();
1.1107 +
1.1108 + __UHEAP_MARKEND;
1.1109 + }
1.1110 +
1.1111 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1112 + {
1.1113 + __UHEAP_MARK;
1.1114 + // w* State Initial
1.1115 + RWsSession rws;
1.1116 + TInt err = rws.Connect();
1.1117 + CleanupClosePushL(rws);
1.1118 + TEST(err==KErrNone);
1.1119 +
1.1120 + if (aEnableWindowSizeCache)
1.1121 + {
1.1122 + rws.EnableWindowSizeCacheL();
1.1123 + }
1.1124 +
1.1125 + RWindowGroup wg(rws);
1.1126 + wg.Construct(0);
1.1127 + CleanupClosePushL(rws);
1.1128 +
1.1129 + // w1 State 0
1.1130 + RWindow w1(rws);
1.1131 + w1.Construct(wg,1);
1.1132 + CleanupClosePushL(w1);
1.1133 +
1.1134 + // w1 State 0
1.1135 + TSize size1 (10001,123);
1.1136 + w1.SetSize(size1);
1.1137 + rws.Flush();
1.1138 +
1.1139 + // w1 State 1
1.1140 + TSize retSize1 = w1.Size();
1.1141 + TEST(retSize1 == size1);
1.1142 +
1.1143 + // w1 State 2
1.1144 + TSize size2 (20002,223);
1.1145 + w1.SetSize(size2);
1.1146 +
1.1147 + // w1 State 2
1.1148 + TPoint point3 (30303,232);
1.1149 + TSize size3 (30003,323);
1.1150 + err = w1.SetExtentErr(point3, size3);
1.1151 + TEST(KErrNone == err);
1.1152 +
1.1153 + // w1 State Final
1.1154 + CleanupStack::Pop();
1.1155 + w1.Close();
1.1156 +
1.1157 + CleanupStack::Pop();
1.1158 + wg.Close();
1.1159 +
1.1160 + CleanupStack::Pop();
1.1161 + rws.Close();
1.1162 +
1.1163 + __UHEAP_MARKEND;
1.1164 + }
1.1165 +
1.1166 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeEnableWindowSizeCacheL()
1.1167 + {
1.1168 + __UHEAP_MARK;
1.1169 + // w* State Initial
1.1170 + RWsSession rws;
1.1171 + TInt err = rws.Connect();
1.1172 + CleanupClosePushL(rws);
1.1173 + TEST(err==KErrNone);
1.1174 +
1.1175 + rws.EnableWindowSizeCacheL();
1.1176 +
1.1177 + RWindowGroup wg(rws);
1.1178 + wg.Construct(0);
1.1179 + CleanupClosePushL(rws);
1.1180 +
1.1181 + // w1 State 0
1.1182 + RWindow w1(rws);
1.1183 + w1.Construct(wg,1);
1.1184 + CleanupClosePushL(w1);
1.1185 +
1.1186 + // w1 State 0
1.1187 + TSize size1 (10001,123);
1.1188 + w1.SetSize(size1);
1.1189 + rws.Flush();
1.1190 +
1.1191 + // w1 State 1
1.1192 + TSize retSize1 = w1.Size();
1.1193 + TEST(retSize1 == size1);
1.1194 +
1.1195 + // w1 State 2
1.1196 + TSize size2 (20002,223);
1.1197 + w1.SetSize(size2);
1.1198 +
1.1199 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.1200 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.1201 + rws.EnableWindowSizeCacheL();
1.1202 +
1.1203 + // w1 State Final
1.1204 + CleanupStack::Pop();
1.1205 + w1.Close();
1.1206 +
1.1207 + CleanupStack::Pop();
1.1208 + wg.Close();
1.1209 +
1.1210 + CleanupStack::Pop();
1.1211 + rws.Close();
1.1212 +
1.1213 + __UHEAP_MARKEND;
1.1214 + }
1.1215 +
1.1216 +//-------------------------------------------------------------------------------------------
1.1217 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(TSizeCacheStatus aEnableWindowSizeCache)
1.1218 + {
1.1219 + __UHEAP_MARK;
1.1220 + // w* State Initial
1.1221 + RWsSession rws;
1.1222 + TInt err = rws.Connect();
1.1223 + CleanupClosePushL(rws);
1.1224 + TEST(err==KErrNone);
1.1225 +
1.1226 + if (aEnableWindowSizeCache)
1.1227 + {
1.1228 + rws.EnableWindowSizeCacheL();
1.1229 + }
1.1230 +
1.1231 + RWindowGroup wg(rws);
1.1232 + wg.Construct(0);
1.1233 + CleanupClosePushL(rws);
1.1234 +
1.1235 + // w1 State 0
1.1236 + RWindow w1(rws);
1.1237 + w1.Construct(wg,1);
1.1238 + CleanupClosePushL(w1);
1.1239 +
1.1240 + // w1 State 0
1.1241 + TSize size1 (10001,123);
1.1242 + w1.SetSize(size1);
1.1243 + rws.Flush();
1.1244 +
1.1245 + // w1 State 1
1.1246 + TSize retSize1 = w1.Size();
1.1247 + TEST(retSize1 == size1);
1.1248 +
1.1249 + // w1 State 2
1.1250 + TSize size2 (20002,223);
1.1251 + w1.SetSize(size2);
1.1252 + rws.Flush();
1.1253 +
1.1254 + // w1 State 1
1.1255 + TSize retSize2 = w1.Size();
1.1256 + TEST(retSize2 == size2);
1.1257 +
1.1258 + // w1 State Final
1.1259 + CleanupStack::Pop();
1.1260 + w1.Close();
1.1261 +
1.1262 + CleanupStack::Pop();
1.1263 + wg.Close();
1.1264 +
1.1265 + CleanupStack::Pop();
1.1266 + rws.Close();
1.1267 +
1.1268 + __UHEAP_MARKEND;
1.1269 + }
1.1270 +
1.1271 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.1272 + {
1.1273 + __UHEAP_MARK;
1.1274 + // w* State Initial
1.1275 + RWsSession rws;
1.1276 + TInt err = rws.Connect();
1.1277 + CleanupClosePushL(rws);
1.1278 + TEST(err==KErrNone);
1.1279 +
1.1280 + if (aEnableWindowSizeCache)
1.1281 + {
1.1282 + rws.EnableWindowSizeCacheL();
1.1283 + }
1.1284 +
1.1285 + RWindowGroup wg(rws);
1.1286 + wg.Construct(0);
1.1287 + CleanupClosePushL(rws);
1.1288 +
1.1289 + // w1 State 0
1.1290 + RWindow w1(rws);
1.1291 + w1.Construct(wg,1);
1.1292 + CleanupClosePushL(w1);
1.1293 +
1.1294 + // w1 State 0
1.1295 + TSize size1 (10001,123);
1.1296 + w1.SetSize(size1);
1.1297 + rws.Flush();
1.1298 +
1.1299 + // w1 State 1
1.1300 + TSize retSize1 = w1.Size();
1.1301 + TEST(retSize1 == size1);
1.1302 +
1.1303 + // w1 State 2
1.1304 + TPoint point2 (20202,223);
1.1305 + TSize size2 (20002,223);
1.1306 + w1.SetExtent(point2, size2);
1.1307 + rws.Flush();
1.1308 +
1.1309 + // w1 State 1
1.1310 + TSize retSize2 = w1.Size();
1.1311 + TEST(retSize2 == size2);
1.1312 +
1.1313 + // w1 State Final
1.1314 + CleanupStack::Pop();
1.1315 + w1.Close();
1.1316 +
1.1317 + CleanupStack::Pop();
1.1318 + wg.Close();
1.1319 +
1.1320 + CleanupStack::Pop();
1.1321 + rws.Close();
1.1322 +
1.1323 + __UHEAP_MARKEND;
1.1324 + }
1.1325 +
1.1326 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1327 + {
1.1328 + __UHEAP_MARK;
1.1329 + // w* State Initial
1.1330 + RWsSession rws;
1.1331 + TInt err = rws.Connect();
1.1332 + CleanupClosePushL(rws);
1.1333 + TEST(err==KErrNone);
1.1334 +
1.1335 + if (aEnableWindowSizeCache)
1.1336 + {
1.1337 + rws.EnableWindowSizeCacheL();
1.1338 + }
1.1339 +
1.1340 + RWindowGroup wg(rws);
1.1341 + wg.Construct(0);
1.1342 + CleanupClosePushL(rws);
1.1343 +
1.1344 + // w1 State 0
1.1345 + RWindow w1(rws);
1.1346 + w1.Construct(wg,1);
1.1347 + CleanupClosePushL(w1);
1.1348 +
1.1349 + // w1 State 0
1.1350 + TSize size1 (10001,123);
1.1351 + w1.SetSize(size1);
1.1352 + rws.Flush();
1.1353 +
1.1354 + // w1 State 1
1.1355 + TSize retSize1 = w1.Size();
1.1356 + TEST(retSize1 == size1);
1.1357 +
1.1358 + // w1 State 2
1.1359 + TSize size2 (20002,223);
1.1360 + err = w1.SetSizeErr(size2);
1.1361 + TEST(KErrNone == err);
1.1362 +
1.1363 + // w1 State 1
1.1364 + TSize retSize2 = w1.Size();
1.1365 + TEST(retSize2 == size2);
1.1366 +
1.1367 + // w1 State Final
1.1368 + CleanupStack::Pop();
1.1369 + w1.Close();
1.1370 +
1.1371 + CleanupStack::Pop();
1.1372 + wg.Close();
1.1373 +
1.1374 + CleanupStack::Pop();
1.1375 + rws.Close();
1.1376 +
1.1377 + __UHEAP_MARKEND;
1.1378 + }
1.1379 +
1.1380 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1381 + {
1.1382 + __UHEAP_MARK;
1.1383 + // w* State Initial
1.1384 + RWsSession rws;
1.1385 + TInt err = rws.Connect();
1.1386 + CleanupClosePushL(rws);
1.1387 + TEST(err==KErrNone);
1.1388 +
1.1389 + if (aEnableWindowSizeCache)
1.1390 + {
1.1391 + rws.EnableWindowSizeCacheL();
1.1392 + }
1.1393 +
1.1394 + RWindowGroup wg(rws);
1.1395 + wg.Construct(0);
1.1396 + CleanupClosePushL(rws);
1.1397 +
1.1398 + // w1 State 0
1.1399 + RWindow w1(rws);
1.1400 + w1.Construct(wg,1);
1.1401 + CleanupClosePushL(w1);
1.1402 +
1.1403 + // w1 State 0
1.1404 + TSize size1 (10001,123);
1.1405 + w1.SetSize(size1);
1.1406 + rws.Flush();
1.1407 +
1.1408 + // w1 State 1
1.1409 + TSize retSize1 = w1.Size();
1.1410 + TEST(retSize1 == size1);
1.1411 +
1.1412 + // w1 State 2
1.1413 + TPoint point2 (20202,223);
1.1414 + TSize size2 (20002,223);
1.1415 + err = w1.SetExtentErr(point2, size2);
1.1416 + TEST(KErrNone == err);
1.1417 +
1.1418 + // w1 State 1
1.1419 + TSize retSize2 = w1.Size();
1.1420 + TEST(retSize2 == size2);
1.1421 +
1.1422 + // w1 State Final
1.1423 + CleanupStack::Pop();
1.1424 + w1.Close();
1.1425 +
1.1426 + CleanupStack::Pop();
1.1427 + wg.Close();
1.1428 +
1.1429 + CleanupStack::Pop();
1.1430 + rws.Close();
1.1431 +
1.1432 + __UHEAP_MARKEND;
1.1433 + }
1.1434 +
1.1435 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(TSizeCacheStatus aEnableWindowSizeCache)
1.1436 + {
1.1437 + __UHEAP_MARK;
1.1438 + // w* State Initial
1.1439 + RWsSession rws;
1.1440 + TInt err = rws.Connect();
1.1441 + CleanupClosePushL(rws);
1.1442 + TEST(err==KErrNone);
1.1443 +
1.1444 + if (aEnableWindowSizeCache)
1.1445 + {
1.1446 + rws.EnableWindowSizeCacheL();
1.1447 + }
1.1448 +
1.1449 + RWindowGroup wg(rws);
1.1450 + wg.Construct(0);
1.1451 + CleanupClosePushL(rws);
1.1452 +
1.1453 + // w1 State 0
1.1454 + RWindow w1(rws);
1.1455 + w1.Construct(wg,1);
1.1456 + CleanupClosePushL(w1);
1.1457 +
1.1458 + // w1 State 0
1.1459 + TSize size1 (10001,123);
1.1460 + w1.SetSize(size1);
1.1461 + rws.Flush();
1.1462 +
1.1463 + // w1 State 1
1.1464 + TSize retSize1 = w1.Size();
1.1465 + TEST(retSize1 == size1);
1.1466 +
1.1467 + // w1 State 2
1.1468 + TSize size2 (20002,223);
1.1469 + w1.SetSize(size2);
1.1470 +
1.1471 + TSize size3 (30003,323);
1.1472 + // w1 State 2
1.1473 + w1.SetSize(size3);
1.1474 + rws.Flush();
1.1475 +
1.1476 + // w1 State 1
1.1477 + TSize retSize2 = w1.Size();
1.1478 + TEST(retSize2 == size3);
1.1479 +
1.1480 + // w1 State Final
1.1481 + CleanupStack::Pop();
1.1482 + w1.Close();
1.1483 +
1.1484 + CleanupStack::Pop();
1.1485 + wg.Close();
1.1486 +
1.1487 + CleanupStack::Pop();
1.1488 + rws.Close();
1.1489 +
1.1490 + __UHEAP_MARKEND;
1.1491 + }
1.1492 +
1.1493 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.1494 + {
1.1495 + __UHEAP_MARK;
1.1496 + // w* State Initial
1.1497 + RWsSession rws;
1.1498 + TInt err = rws.Connect();
1.1499 + CleanupClosePushL(rws);
1.1500 + TEST(err==KErrNone);
1.1501 +
1.1502 + if (aEnableWindowSizeCache)
1.1503 + {
1.1504 + rws.EnableWindowSizeCacheL();
1.1505 + }
1.1506 +
1.1507 + RWindowGroup wg(rws);
1.1508 + wg.Construct(0);
1.1509 + CleanupClosePushL(rws);
1.1510 +
1.1511 + // w1 State 0
1.1512 + RWindow w1(rws);
1.1513 + w1.Construct(wg,1);
1.1514 + CleanupClosePushL(w1);
1.1515 +
1.1516 + // w1 State 0
1.1517 + TSize size1 (10001,123);
1.1518 + w1.SetSize(size1);
1.1519 + rws.Flush();
1.1520 +
1.1521 + // w1 State 1
1.1522 + TSize retSize1 = w1.Size();
1.1523 + TEST(retSize1 == size1);
1.1524 +
1.1525 + // w1 State 2
1.1526 + TSize size2 (20002,223);
1.1527 + w1.SetSize(size2);
1.1528 +
1.1529 + // w1 State 2
1.1530 + TPoint point3 (30303,232);
1.1531 + TSize size3 (30003,323);
1.1532 + w1.SetExtent(point3, size3);
1.1533 + rws.Flush();
1.1534 +
1.1535 + // w1 State 1
1.1536 + TSize retSize2 = w1.Size();
1.1537 + TEST(retSize2 == size3);
1.1538 +
1.1539 + // w1 State Final
1.1540 + CleanupStack::Pop();
1.1541 + w1.Close();
1.1542 +
1.1543 + CleanupStack::Pop();
1.1544 + wg.Close();
1.1545 +
1.1546 + CleanupStack::Pop();
1.1547 + rws.Close();
1.1548 +
1.1549 + __UHEAP_MARKEND;
1.1550 + }
1.1551 +
1.1552 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1553 + {
1.1554 + __UHEAP_MARK;
1.1555 + // w* State Initial
1.1556 + RWsSession rws;
1.1557 + TInt err = rws.Connect();
1.1558 + CleanupClosePushL(rws);
1.1559 + TEST(err==KErrNone);
1.1560 +
1.1561 + if (aEnableWindowSizeCache)
1.1562 + {
1.1563 + rws.EnableWindowSizeCacheL();
1.1564 + }
1.1565 +
1.1566 + RWindowGroup wg(rws);
1.1567 + wg.Construct(0);
1.1568 + CleanupClosePushL(rws);
1.1569 +
1.1570 + // w1 State 0
1.1571 + RWindow w1(rws);
1.1572 + w1.Construct(wg,1);
1.1573 + CleanupClosePushL(w1);
1.1574 +
1.1575 + // w1 State 0
1.1576 + TSize size1 (10001,123);
1.1577 + w1.SetSize(size1);
1.1578 + rws.Flush();
1.1579 +
1.1580 + // w1 State 1
1.1581 + TSize retSize1 = w1.Size();
1.1582 + TEST(retSize1 == size1);
1.1583 +
1.1584 + // w1 State 2
1.1585 + TSize size2 (20002,223);
1.1586 + w1.SetSize(size2);
1.1587 +
1.1588 + // w1 State 2
1.1589 + TSize size3 (30003,323);
1.1590 + err = w1.SetSizeErr(size3);
1.1591 + TEST(KErrNone == err);
1.1592 +
1.1593 + // w1 State 1
1.1594 + TSize retSize2 = w1.Size();
1.1595 + TEST(retSize2 == size3);
1.1596 +
1.1597 + // w1 State Final
1.1598 + CleanupStack::Pop();
1.1599 + w1.Close();
1.1600 +
1.1601 + CleanupStack::Pop();
1.1602 + wg.Close();
1.1603 +
1.1604 + CleanupStack::Pop();
1.1605 + rws.Close();
1.1606 +
1.1607 + __UHEAP_MARKEND;
1.1608 + }
1.1609 +
1.1610 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1611 + {
1.1612 + __UHEAP_MARK;
1.1613 + // w* State Initial
1.1614 + RWsSession rws;
1.1615 + TInt err = rws.Connect();
1.1616 + CleanupClosePushL(rws);
1.1617 + TEST(err==KErrNone);
1.1618 +
1.1619 + if (aEnableWindowSizeCache)
1.1620 + {
1.1621 + rws.EnableWindowSizeCacheL();
1.1622 + }
1.1623 +
1.1624 + RWindowGroup wg(rws);
1.1625 + wg.Construct(0);
1.1626 + CleanupClosePushL(rws);
1.1627 +
1.1628 + // w1 State 0
1.1629 + RWindow w1(rws);
1.1630 + w1.Construct(wg,1);
1.1631 + CleanupClosePushL(w1);
1.1632 +
1.1633 + // w1 State 0
1.1634 + TSize size1 (10001,123);
1.1635 + w1.SetSize(size1);
1.1636 + rws.Flush();
1.1637 +
1.1638 + // w1 State 1
1.1639 + TSize retSize1 = w1.Size();
1.1640 + TEST(retSize1 == size1);
1.1641 +
1.1642 + // w1 State 2
1.1643 + TSize size2 (20002,223);
1.1644 + w1.SetSize(size2);
1.1645 +
1.1646 + // w1 State 2
1.1647 + TPoint point3 (30303,232);
1.1648 + TSize size3 (30003,323);
1.1649 + err = w1.SetExtentErr(point3, size3);
1.1650 + TEST(KErrNone == err);
1.1651 +
1.1652 + // w1 State 1
1.1653 + TSize retSize2 = w1.Size();
1.1654 + TEST(retSize2 == size3);
1.1655 +
1.1656 + // w1 State Final
1.1657 + CleanupStack::Pop();
1.1658 + w1.Close();
1.1659 +
1.1660 + CleanupStack::Pop();
1.1661 + wg.Close();
1.1662 +
1.1663 + CleanupStack::Pop();
1.1664 + rws.Close();
1.1665 +
1.1666 + __UHEAP_MARKEND;
1.1667 + }
1.1668 +
1.1669 +void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeEnableWindowSizeCacheL()
1.1670 + {
1.1671 + __UHEAP_MARK;
1.1672 + // w* State Initial
1.1673 + RWsSession rws;
1.1674 + TInt err = rws.Connect();
1.1675 + CleanupClosePushL(rws);
1.1676 + TEST(err==KErrNone);
1.1677 +
1.1678 + rws.EnableWindowSizeCacheL();
1.1679 +
1.1680 + RWindowGroup wg(rws);
1.1681 + wg.Construct(0);
1.1682 + CleanupClosePushL(rws);
1.1683 +
1.1684 + // w1 State 0
1.1685 + RWindow w1(rws);
1.1686 + w1.Construct(wg,1);
1.1687 + CleanupClosePushL(w1);
1.1688 +
1.1689 + // w1 State 0
1.1690 + TSize size1 (10001,123);
1.1691 + w1.SetSize(size1);
1.1692 + rws.Flush();
1.1693 +
1.1694 + // w1 State 1
1.1695 + TSize retSize1 = w1.Size();
1.1696 + TEST(retSize1 == size1);
1.1697 +
1.1698 + // w1 State 2
1.1699 + TSize size2 (20002,223);
1.1700 + w1.SetSize(size2);
1.1701 +
1.1702 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.1703 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.1704 + rws.EnableWindowSizeCacheL();
1.1705 +
1.1706 + // w1 State 1
1.1707 + TSize retSize2 = w1.Size();
1.1708 + TEST(retSize2 == size2);
1.1709 +
1.1710 + // w1 State Final
1.1711 + CleanupStack::Pop();
1.1712 + w1.Close();
1.1713 +
1.1714 + CleanupStack::Pop();
1.1715 + wg.Close();
1.1716 +
1.1717 + CleanupStack::Pop();
1.1718 + rws.Close();
1.1719 +
1.1720 + __UHEAP_MARKEND;
1.1721 + }
1.1722 +
1.1723 +//------------------------------------------------------------------------------------------
1.1724 +
1.1725 +void CTWindowSizeCacheTest::TestRBlankWindowSetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)
1.1726 + {
1.1727 + __UHEAP_MARK;
1.1728 + // w* State Initial
1.1729 + RWsSession rws;
1.1730 + TInt err = rws.Connect();
1.1731 + CleanupClosePushL(rws);
1.1732 + TEST(err==KErrNone);
1.1733 +
1.1734 + if (aEnableWindowSizeCache)
1.1735 + {
1.1736 + rws.EnableWindowSizeCacheL();
1.1737 + }
1.1738 +
1.1739 + RWindowGroup wg(rws);
1.1740 + err = wg.Construct(0);
1.1741 + CleanupClosePushL(rws);
1.1742 + TEST(err==KErrNone);
1.1743 +
1.1744 + // w1 State 0
1.1745 + RBlankWindow w1(rws);
1.1746 + err = w1.Construct(wg,1);
1.1747 + CleanupClosePushL(w1);
1.1748 + TEST(err==KErrNone);
1.1749 +
1.1750 + // w1 State 0
1.1751 + TSize size1 (10001,123);
1.1752 + w1.SetSize(size1);
1.1753 + rws.Flush();
1.1754 +
1.1755 + // w1 State 1
1.1756 + TSize retSize1 = w1.Size();
1.1757 + TEST(retSize1 == size1);
1.1758 +
1.1759 + // w1 State 2
1.1760 + TSize size2 (20002,223);
1.1761 + w1.SetSize(size2);
1.1762 +
1.1763 + // w1 State 2
1.1764 + TPoint point3 (30303,232);
1.1765 + TSize size3 (30003,323);
1.1766 + w1.SetExtent(point3, size3);
1.1767 + rws.Flush();
1.1768 +
1.1769 + // w1 State 1
1.1770 + TSize retSize2 = w1.Size();
1.1771 + TEST(retSize2 == size3);
1.1772 +
1.1773 + // w1 State 2
1.1774 + TSize size4 (40004,423);
1.1775 + w1.SetSize(size4);
1.1776 +
1.1777 + // w1 State 1
1.1778 + TSize retSize3 = w1.Size();
1.1779 + TEST(retSize3 == size4);
1.1780 +
1.1781 + // w1 State Final
1.1782 + CleanupStack::Pop();
1.1783 + w1.Close();
1.1784 +
1.1785 + CleanupStack::Pop();
1.1786 + wg.Close();
1.1787 +
1.1788 + CleanupStack::Pop();
1.1789 + rws.Close();
1.1790 +
1.1791 + __UHEAP_MARKEND;
1.1792 + }
1.1793 +
1.1794 +//------------------------------------------------------------------------------------------
1.1795 +
1.1796 +void CTWindowSizeCacheTest::TestRBackedUpWindowSetSizeErrSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)
1.1797 + {
1.1798 + __UHEAP_MARK;
1.1799 + // w* State Initial
1.1800 + RWsSession rws;
1.1801 + TInt err = rws.Connect();
1.1802 + CleanupClosePushL(rws);
1.1803 + TEST(err==KErrNone);
1.1804 +
1.1805 + if (aEnableWindowSizeCache)
1.1806 + {
1.1807 + rws.EnableWindowSizeCacheL();
1.1808 + }
1.1809 +
1.1810 + RWindowGroup wg(rws);
1.1811 + err = wg.Construct(0);
1.1812 + CleanupClosePushL(rws);
1.1813 + TEST(err==KErrNone);
1.1814 +
1.1815 + // w1 State 0
1.1816 + RBlankWindow w1(rws);
1.1817 + err = w1.Construct(wg,1);
1.1818 + CleanupClosePushL(w1);
1.1819 + TEST(err==KErrNone);
1.1820 +
1.1821 + // w1 State 0
1.1822 + TSize size1 (10001,123);
1.1823 + err = w1.SetSizeErr(size1);
1.1824 + TEST(err==KErrNone);
1.1825 +
1.1826 + // w1 State 1
1.1827 + TSize retSize1 = w1.Size();
1.1828 + TEST(retSize1 == size1);
1.1829 +
1.1830 + // w1 State 2
1.1831 + TSize size2 (20002,223);
1.1832 + err = w1.SetSizeErr(size2);
1.1833 + TEST(err==KErrNone);
1.1834 +
1.1835 + // w1 State 2
1.1836 + TPoint point3 (30303,232);
1.1837 + TSize size3 (30003,323);
1.1838 + err = w1.SetExtentErr(point3, size3);
1.1839 + TEST(err==KErrNone);
1.1840 +
1.1841 + // w1 State 1
1.1842 + TSize retSize2 = w1.Size();
1.1843 + TEST(retSize2 == size3);
1.1844 +
1.1845 + // w1 State 2
1.1846 + TSize size4 (40004,423);
1.1847 + err = w1.SetSizeErr(size4);
1.1848 + TEST(err==KErrNone);
1.1849 +
1.1850 + // w1 State 1
1.1851 + TSize retSize3 = w1.Size();
1.1852 + TEST(retSize3 == size4);
1.1853 +
1.1854 + // w1 State Final
1.1855 + CleanupStack::Pop();
1.1856 + w1.Close();
1.1857 +
1.1858 + CleanupStack::Pop();
1.1859 + wg.Close();
1.1860 +
1.1861 + CleanupStack::Pop();
1.1862 + rws.Close();
1.1863 +
1.1864 + __UHEAP_MARKEND;
1.1865 + }
1.1866 +
1.1867 +//------------------------------------------------------------------------------------------
1.1868 +
1.1869 +TUint64 CTWindowSizeCacheTest::TestRWindowSizePerformanceL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)
1.1870 + {
1.1871 + TUint64 timeDeltaMicroSeconds = 0;
1.1872 +
1.1873 + __UHEAP_MARK;
1.1874 + // w* State Initial
1.1875 + RWsSession rws;
1.1876 + TInt err = rws.Connect();
1.1877 + TEST(KErrNone == err);
1.1878 + CleanupClosePushL(rws);
1.1879 +
1.1880 + if (ETestSizeCacheEnabled == aEnableWindowSizeCache)
1.1881 + {
1.1882 + rws.EnableWindowSizeCacheL();
1.1883 + }
1.1884 +
1.1885 + RWindowGroup wg(rws);
1.1886 + err = wg.Construct(0);
1.1887 + TEST(KErrNone == err);
1.1888 + CleanupClosePushL(wg);
1.1889 +
1.1890 + // w1 State 0
1.1891 + RWindow w1(rws);
1.1892 + err = w1.Construct(wg,1);
1.1893 + TEST(KErrNone == err);
1.1894 + CleanupClosePushL(w1);
1.1895 +
1.1896 + TSize size1 (10001,123);
1.1897 + w1.SetSize(size1);
1.1898 +
1.1899 + TTime start;
1.1900 + TTime end;
1.1901 + start.UniversalTime();
1.1902 + for (TUint iter = 0; iter < aIterations; ++iter)
1.1903 + {
1.1904 + // w1 State 1
1.1905 + TSize retSize1 = w1.Size();
1.1906 + TEST(retSize1 == size1);
1.1907 + }
1.1908 + end.UniversalTime();
1.1909 +
1.1910 + TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(start);
1.1911 + timeDeltaMicroSeconds = delta.Int64();
1.1912 + INFO_PRINTF4(_L("TestRWindowSizePerformanceL - WindowSizeCacheEnabled %d, Iterations %d, Microseconds %Ld"), aEnableWindowSizeCache, aIterations, timeDeltaMicroSeconds);
1.1913 +
1.1914 + // w1 State Final
1.1915 + CleanupStack::Pop();
1.1916 + w1.Close();
1.1917 +
1.1918 + CleanupStack::Pop();
1.1919 + wg.Close();
1.1920 +
1.1921 + CleanupStack::Pop();
1.1922 + rws.Close();
1.1923 +
1.1924 + __UHEAP_MARKEND;
1.1925 + return timeDeltaMicroSeconds;
1.1926 + }
1.1927 +
1.1928 +
1.1929 +//------------------------------------------------------------------------------------------
1.1930 +/*
1.1931 +Sets the random seed used by CTWindowSizeCacheTest::NextRandom.
1.1932 + */
1.1933 +void CTWindowSizeCacheTest::SetRandomSeed(TInt64 aSeed)
1.1934 + {
1.1935 + INFO_PRINTF2(_L("Random Seed - %d"), aSeed);
1.1936 + iSeed = aSeed;
1.1937 + }
1.1938 +
1.1939 +/*
1.1940 +Performs an action on RWindow or RWsSession as specified by TRWindowAction aAction.
1.1941 +When the size of the window is changed, aExpectedSize is changed to the size we expect the window to be the next time RWindow::Size is called.
1.1942 +When RWindow::Size is called, we check the size returned matches aExpectedSize.
1.1943 +If aAction requests RWsSession::EnableWindowSizeCache, we call this if TSizeCacheStatus allows this.
1.1944 +
1.1945 +This function was designed for use with random stress tests, with a pseudo-random sequence driving TRWindowAction.
1.1946 + */
1.1947 +void CTWindowSizeCacheTest::RWindowPerformAction(TRWindowAction aAction, TSizeCacheStatus aEnableWindowSizeCache, RWsSession& aWs, RWindow& aWindow, TSize& aExpectedSize)
1.1948 + {
1.1949 + switch (aAction)
1.1950 + {
1.1951 + case ESetExtent :
1.1952 + {
1.1953 + TPoint point(NextRandom(), NextRandom());
1.1954 + aExpectedSize.iHeight = NextRandom();
1.1955 + aExpectedSize.iWidth = NextRandom();
1.1956 + aWindow.SetExtent(point, aExpectedSize);
1.1957 + aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;
1.1958 + aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;
1.1959 + }
1.1960 + break;
1.1961 + case ESetExtentErr :
1.1962 + {
1.1963 + TPoint point(NextRandom(), NextRandom());
1.1964 + aExpectedSize.iHeight = NextRandom();
1.1965 + aExpectedSize.iWidth = NextRandom();
1.1966 + TInt err = aWindow.SetExtentErr(point, aExpectedSize);
1.1967 + TEST(KErrNone == err);
1.1968 + aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;
1.1969 + aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;
1.1970 + }
1.1971 + break;
1.1972 + case ESetSize :
1.1973 + {
1.1974 + aExpectedSize.iHeight = NextRandom();
1.1975 + aExpectedSize.iWidth = NextRandom();
1.1976 + aWindow.SetSize(aExpectedSize);
1.1977 + aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;
1.1978 + aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;
1.1979 + }
1.1980 + break;
1.1981 + case ESetSizeErr :
1.1982 + {
1.1983 + aExpectedSize.iHeight = NextRandom();
1.1984 + aExpectedSize.iWidth = NextRandom();
1.1985 + TInt err = aWindow.SetSizeErr(aExpectedSize);
1.1986 + TEST(KErrNone == err);
1.1987 + aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;
1.1988 + aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;
1.1989 + }
1.1990 + break;
1.1991 + case ECheckSize :
1.1992 + {
1.1993 + TSize retSize1 = aWindow.Size();
1.1994 + TEST(retSize1 == aExpectedSize);
1.1995 + }
1.1996 + break;
1.1997 + case EFlushSession :
1.1998 + {
1.1999 + aWs.Flush();
1.2000 + }
1.2001 + break;
1.2002 + case EEnableWindowSizeCache :
1.2003 + {
1.2004 + if (ETestSizeCacheEnabled == aEnableWindowSizeCache)
1.2005 + {
1.2006 + aWs.EnableWindowSizeCacheL();
1.2007 + }
1.2008 + }
1.2009 + break;
1.2010 + default :
1.2011 + break;
1.2012 + }
1.2013 + }
1.2014 +
1.2015 +void CTWindowSizeCacheTest::TestRandomisedStressL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)
1.2016 + {
1.2017 + __UHEAP_MARK;
1.2018 + // w* State Initial
1.2019 + RWsSession rws;
1.2020 + TInt err = rws.Connect();
1.2021 + TEST(KErrNone == err);
1.2022 + CleanupClosePushL(rws);
1.2023 +
1.2024 + if (aEnableWindowSizeCache)
1.2025 + {
1.2026 + rws.EnableWindowSizeCacheL();
1.2027 + }
1.2028 +
1.2029 + RWindowGroup wg(rws);
1.2030 + err = wg.Construct(0);
1.2031 + TEST(KErrNone == err);
1.2032 + CleanupClosePushL(wg);
1.2033 +
1.2034 + // w1 State 0
1.2035 + RWindow w1(rws);
1.2036 + err = w1.Construct(wg,1);
1.2037 + TEST(KErrNone == err);
1.2038 + CleanupClosePushL(w1);
1.2039 +
1.2040 + TSize size1 (10001,123);
1.2041 + w1.SetSize(size1);
1.2042 +
1.2043 + for (TUint iter = 0; iter < aIterations; ++iter)
1.2044 + {
1.2045 + TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));
1.2046 + RWindowPerformAction(action, aEnableWindowSizeCache, rws, w1, size1);
1.2047 + }
1.2048 +
1.2049 + // w1 State Final
1.2050 + CleanupStack::Pop();
1.2051 + w1.Close();
1.2052 +
1.2053 + CleanupStack::Pop();
1.2054 + wg.Close();
1.2055 +
1.2056 + CleanupStack::Pop();
1.2057 + rws.Close();
1.2058 + __UHEAP_MARKEND;
1.2059 + }
1.2060 +
1.2061 +/*
1.2062 +TCleanupOperation for a window pool, implemented as RPointerArray<RWindow>.
1.2063 + */
1.2064 +void CTWindowSizeCacheTest::CleanupWindowPool(TAny* aPtr)
1.2065 + {
1.2066 + RPointerArray<RWindow> windowPool = *(static_cast<RPointerArray<RWindow>*>(aPtr));
1.2067 + const TUint poolSize = windowPool.Count();
1.2068 + // Note: ResetAndDestroy deletes referenced objects, so no need to delete items in loop
1.2069 + for (TUint iter = 0; iter < poolSize; ++iter)
1.2070 + {
1.2071 + windowPool[iter]->Close();
1.2072 + }
1.2073 + windowPool.ResetAndDestroy();
1.2074 + }
1.2075 +
1.2076 +void CTWindowSizeCacheTest::TestRandomisedStressMultiSessionL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)
1.2077 + {
1.2078 + __UHEAP_MARK;
1.2079 + // w* State Initial
1.2080 + RWsSession rws1;
1.2081 + TInt err = rws1.Connect();
1.2082 + TEST(KErrNone == err);
1.2083 + CleanupClosePushL(rws1);
1.2084 +
1.2085 + // Multiple sessions in one thread
1.2086 + RWsSession rws2;
1.2087 + err = rws2.Connect();
1.2088 + TEST(KErrNone == err);
1.2089 + CleanupClosePushL(rws2);
1.2090 +
1.2091 + RWindowGroup rws1_wg1(rws1);
1.2092 + err = rws1_wg1.Construct(0);
1.2093 + CleanupClosePushL(rws1_wg1);
1.2094 + TEST(KErrNone == err);
1.2095 +
1.2096 + RWindowGroup rws2_wg1(rws2);
1.2097 + err = rws2_wg1.Construct(0);
1.2098 + CleanupClosePushL(rws2_wg1);
1.2099 + TEST(KErrNone == err);
1.2100 +
1.2101 + // Multiple window groups in one session
1.2102 + RWindowGroup rws2_wg2(rws2);
1.2103 + err = rws2_wg2.Construct(1);
1.2104 + CleanupClosePushL(rws2_wg2);
1.2105 + TEST(KErrNone == err);
1.2106 +
1.2107 + // Window pool for all windows owned by session rws1
1.2108 + RPointerArray<RWindow> rws1_windowPool;
1.2109 + CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&rws1_windowPool));
1.2110 + // Each window in window pool has a corresponding expected size at corresponding array index
1.2111 + RArray<TSize> rws1_expectedSizePool;
1.2112 + CleanupClosePushL(rws1_expectedSizePool);
1.2113 +
1.2114 + // Window pool for all windows owned by session rws2
1.2115 + RPointerArray<RWindow> rws2_windowPool;
1.2116 + CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&rws2_windowPool));
1.2117 + // Each window in window pool has a corresponding expected size at corresponding array index
1.2118 + RArray<TSize> rws2_expectedSizePool;
1.2119 + CleanupClosePushL(rws2_expectedSizePool);
1.2120 +
1.2121 + // Populate window pool
1.2122 + const TUint KWindowCount_rws1_wg1 = 50;
1.2123 + const TUint KWindowCount_rws2_wg1 = 50;
1.2124 + const TUint KWindowCount_rws2_wg2 = 50;
1.2125 +
1.2126 + // Windows for session 1 belonging to rws1_wg1
1.2127 + // Many windows - siblings
1.2128 + for (TUint iter = 0; iter < KWindowCount_rws1_wg1; ++iter)
1.2129 + {
1.2130 + RWindow* win = new (ELeave) RWindow(rws1);
1.2131 + CleanupStack::PushL(win);
1.2132 + TInt err = win->Construct(rws1_wg1,iter+1);
1.2133 + TEST(KErrNone == err);
1.2134 + rws1_windowPool.AppendL(win);
1.2135 + CleanupStack::Pop(win);
1.2136 + TSize expectedSize (NextRandom(),NextRandom());
1.2137 + win->SetSize(expectedSize);
1.2138 + // Wserv flattens size to zero
1.2139 + expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;
1.2140 + expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;
1.2141 + rws1_expectedSizePool.AppendL(expectedSize);
1.2142 + TSize retSize1 = win->Size();
1.2143 + TEST(retSize1 == expectedSize);
1.2144 + }
1.2145 +
1.2146 + // Windows for session 2 belonging to rws2_wg1
1.2147 + // Many windows - siblings
1.2148 + for (TUint iter = 0; iter < KWindowCount_rws2_wg1; ++iter)
1.2149 + {
1.2150 + RWindow* win = new (ELeave) RWindow(rws2);
1.2151 + CleanupStack::PushL(win);
1.2152 + TInt err = win->Construct(rws2_wg1,iter+2);
1.2153 + TEST(KErrNone == err);
1.2154 + rws2_windowPool.AppendL(win);
1.2155 + CleanupStack::Pop();
1.2156 + TSize expectedSize (NextRandom(),NextRandom());
1.2157 + win->SetSize(expectedSize);
1.2158 + // Wserv flattens size to zero
1.2159 + expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;
1.2160 + expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;
1.2161 + rws2_expectedSizePool.AppendL(expectedSize);
1.2162 + TSize retSize1 = win->Size();
1.2163 + TEST(retSize1 == expectedSize);
1.2164 + }
1.2165 +
1.2166 + // Windows for session 2 belonging to rws2_wg2
1.2167 + // Many windows - children
1.2168 + RWindowTreeNode parent = rws2_wg2;
1.2169 + for (TUint iter = 0; iter < KWindowCount_rws2_wg2; ++iter)
1.2170 + {
1.2171 + RWindow* win = new (ELeave) RWindow(rws2);
1.2172 + CleanupStack::PushL(win);
1.2173 + TInt err = win->Construct(parent,KWindowCount_rws2_wg1+iter+2);
1.2174 + TEST(KErrNone == err);
1.2175 + parent = *win;
1.2176 + rws2_windowPool.AppendL(win);
1.2177 + CleanupStack::Pop();
1.2178 + TSize expectedSize (NextRandom(),NextRandom());
1.2179 + win->SetSize(expectedSize);
1.2180 + // Wserv flattens size to zero
1.2181 + expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;
1.2182 + expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;
1.2183 + rws2_expectedSizePool.AppendL(expectedSize);
1.2184 + TSize retSize1 = win->Size();
1.2185 + TEST(retSize1 == expectedSize);
1.2186 + }
1.2187 +
1.2188 + // Stress system by performing actions on windows
1.2189 + for (TUint iter = 0; iter < aIterations; ++iter)
1.2190 + {
1.2191 + TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));
1.2192 + TUint32 windowPool = NextRandom(2);
1.2193 + switch (windowPool)
1.2194 + {
1.2195 + case 0 :
1.2196 + {
1.2197 + TUint32 target = NextRandom(rws1_windowPool.Count());
1.2198 + RWindowPerformAction(action, aEnableWindowSizeCache, rws1, *(rws1_windowPool[target]) , rws1_expectedSizePool[target]);
1.2199 + }
1.2200 + break;
1.2201 + case 1 :
1.2202 + {
1.2203 + TUint32 target = NextRandom(rws2_windowPool.Count());
1.2204 + RWindowPerformAction(action, aEnableWindowSizeCache, rws2, *(rws2_windowPool[target]) , rws2_expectedSizePool[target]);
1.2205 + }
1.2206 + break;
1.2207 + default :
1.2208 + User::Invariant();
1.2209 + }
1.2210 + }
1.2211 +
1.2212 +
1.2213 + // Cleanup afterwards
1.2214 + CleanupStack::Pop(9);
1.2215 +
1.2216 + CleanupWindowPool(&rws1_windowPool);
1.2217 + rws1_expectedSizePool.Close();
1.2218 + rws1_wg1.Close();
1.2219 + rws1.Close();
1.2220 +
1.2221 + CleanupWindowPool(&rws2_windowPool);
1.2222 + rws2_expectedSizePool.Close();
1.2223 + rws2_wg1.Close();
1.2224 + rws2_wg2.Close();
1.2225 + rws2.Close();
1.2226 + }
1.2227 +
1.2228 +void CTWindowSizeCacheTest::TestRandomisedStressCacheEntryVolumeL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations, TUint aWindowPoolSize)
1.2229 + {
1.2230 + __UHEAP_MARK;
1.2231 + // w* State Initial
1.2232 + RWsSession rws1;
1.2233 + TInt err = rws1.Connect();
1.2234 + TEST(KErrNone == err);
1.2235 + CleanupClosePushL(rws1);
1.2236 +
1.2237 + if (aEnableWindowSizeCache)
1.2238 + {
1.2239 + rws1.EnableWindowSizeCacheL();
1.2240 + }
1.2241 +
1.2242 + RWindowGroup rws1_wg1(rws1);
1.2243 + err = rws1_wg1.Construct(0);
1.2244 + TEST(KErrNone == err);
1.2245 + CleanupClosePushL(rws1_wg1);
1.2246 +
1.2247 + RPointerArray<RWindow> windowPool;
1.2248 + CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&windowPool));
1.2249 + // Each window in window pool has a corresponding expected size at corresponding array index
1.2250 + RArray<TSize> expectedSizePool;
1.2251 + CleanupClosePushL(expectedSizePool);
1.2252 +
1.2253 + // Populate window pool
1.2254 + for (TUint iter = 0; iter < aWindowPoolSize; ++iter)
1.2255 + {
1.2256 + RWindow* win = new (ELeave) RWindow(rws1);
1.2257 + CleanupStack::PushL(win);
1.2258 + TInt err = win->Construct(rws1_wg1,iter+1);
1.2259 + TEST(KErrNone == err);
1.2260 + windowPool.AppendL(win);
1.2261 + CleanupStack::Pop(win);
1.2262 +
1.2263 + TSize expectedSize (NextRandom(),NextRandom());
1.2264 + win->SetSize(expectedSize);
1.2265 + // Wserv flattens size to zero
1.2266 + expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;
1.2267 + expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;
1.2268 + expectedSizePool.AppendL(expectedSize);
1.2269 + TSize retSize1 = win->Size();
1.2270 + TEST(retSize1 == expectedSize);
1.2271 + }
1.2272 +
1.2273 + // Stress system by performing actions on windows
1.2274 + for (TUint iter = 0; iter < aIterations; ++iter)
1.2275 + {
1.2276 + TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));
1.2277 + TUint32 target = NextRandom(aWindowPoolSize);
1.2278 + RWindowPerformAction(action, aEnableWindowSizeCache, rws1, *(windowPool[target]), expectedSizePool[target]);
1.2279 + }
1.2280 +
1.2281 + // Cleanup afterwards
1.2282 + CleanupStack::Pop(4);
1.2283 +
1.2284 + CleanupWindowPool(&windowPool);
1.2285 + expectedSizePool.Close();
1.2286 + rws1_wg1.Close();
1.2287 + rws1.Close();
1.2288 +
1.2289 + __UHEAP_MARKEND;
1.2290 + }
1.2291 +
1.2292 +//------------------------------------------------------------------------------------------
1.2293 +
1.2294 +void CTWindowSizeCacheTest::TestStressEnableWindowSizeCacheL(TUint aIterations)
1.2295 + {
1.2296 + __UHEAP_MARK;
1.2297 + // w* State Initial
1.2298 + RWsSession rws;
1.2299 + TInt err = rws.Connect();
1.2300 + CleanupClosePushL(rws);
1.2301 + TEST(err==KErrNone);
1.2302 +
1.2303 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.2304 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.2305 + for (TUint iter = 0; iter < aIterations; iter++)
1.2306 + {
1.2307 + rws.EnableWindowSizeCacheL();
1.2308 + }
1.2309 +
1.2310 + RWindowGroup wg(rws);
1.2311 + wg.Construct(0);
1.2312 + CleanupClosePushL(rws);
1.2313 +
1.2314 + // w1 State 0
1.2315 + RWindow w1(rws);
1.2316 + w1.Construct(wg,1);
1.2317 + CleanupClosePushL(w1);
1.2318 +
1.2319 + TSize size1 (10001,123);
1.2320 + w1.SetSize(size1);
1.2321 +
1.2322 + // w1 State 1
1.2323 + TSize retSize1 = w1.Size();
1.2324 + TEST(retSize1 == size1);
1.2325 +
1.2326 + // w1 State 2
1.2327 + TSize size2 (20002,223);
1.2328 + w1.SetSize(size2);
1.2329 +
1.2330 + // w1 State 2
1.2331 + // Only the first call to EnableWindowSizeCacheL() should have an effect
1.2332 + // All subsequent calls to EnableWindowSizeCacheL() should have no effect
1.2333 + for (TUint iter = 0; iter < aIterations; iter++)
1.2334 + {
1.2335 + rws.EnableWindowSizeCacheL();
1.2336 + }
1.2337 +
1.2338 + // w1 State 1
1.2339 + TSize retSize2 = w1.Size();
1.2340 + TEST(retSize2 == size2);
1.2341 +
1.2342 + // w1 State Final
1.2343 + CleanupStack::Pop();
1.2344 + w1.Close();
1.2345 +
1.2346 + CleanupStack::Pop();
1.2347 + wg.Close();
1.2348 +
1.2349 + CleanupStack::Pop();
1.2350 + rws.Close();
1.2351 +
1.2352 + __UHEAP_MARKEND;
1.2353 + }
1.2354 +
1.2355 +/*
1.2356 +Tests 701-706 focus on window creation operating correctly, alternating use of the window size cache.
1.2357 +Tests 707-710 aim to cover state transitions for cache entries in the window size cache for RWindow.
1.2358 +Tests 711-712 performs basic verification of size related functionality for RBlankWindow and RBackedUpWindow.
1.2359 +Test 713 focusses on ensuring a performance gain is achieved with window size caching enabled.
1.2360 +Tests 714-720 aim to stress the window size cache with pseudo-random sequences of RWindow size related functions.
1.2361 +
1.2362 +The states in the state machine model used for testing the RWindow size cache in tests 707-710 is as follows:
1.2363 +
1.2364 +State: Initial
1.2365 + Window not yet in existence
1.2366 +
1.2367 +State 0: No Cache entry
1.2368 + Window created, window size cache does not contain an entry for this window
1.2369 +
1.2370 +State 1: Cache entry exists, cache clean
1.2371 + Window created, window size cache exists, contains a valid size
1.2372 +
1.2373 +State 2: Cache entry exists, cache dirty
1.2374 + Window created, window size cache exists, does not contain a valid size
1.2375 +
1.2376 +State: Final
1.2377 + Window destroyed
1.2378 + */
1.2379 +void CTWindowSizeCacheTest::RunTestCaseL(TInt /*aCurTestCase*/)
1.2380 + {
1.2381 + _LIT(KTest1,"Create RWindow, window size cache off");
1.2382 + _LIT(KTest2,"Create RWindow, window size cache on");
1.2383 + _LIT(KTest3,"Create RBlankWindow, window size cache off");
1.2384 + _LIT(KTest4,"Create RBlankWindow, window size cache on");
1.2385 + _LIT(KTest5,"Create RBackedUpWindow, window size cache off");
1.2386 + _LIT(KTest6,"Create RBackedUpWindow, window size cache on");
1.2387 +
1.2388 + _LIT(KTest7,"RWindow - No cache entry");
1.2389 + _LIT(KTest8,"RWindow - Cache entry exists, cache clean");
1.2390 + _LIT(KTest9,"RWindow - Cache entry exists, cache dirty");
1.2391 + _LIT(KTest10,"RWindow - Cache entry exists, cache dirty->clean");
1.2392 +
1.2393 + _LIT(KTest11,"RBlankWindow size cache");
1.2394 + _LIT(KTest12,"RBackedUpWindow size cache");
1.2395 +
1.2396 + _LIT(KTest13,"RWindow Size Performance");
1.2397 + _LIT(KTest14,"RWindow Randomised Stress window size cache off");
1.2398 + _LIT(KTest15,"RWindow Randomised Stress window size cache on");
1.2399 + _LIT(KTest16,"RWindow Randomised Stress MultiSession cache off");
1.2400 + _LIT(KTest17,"RWindow Randomised Stress MultiSession cache on");
1.2401 + _LIT(KTest18,"RWindow Randomised Stress Entry Volume cache off");
1.2402 + _LIT(KTest19,"RWindow Randomised Stress Entry Volume cache on");
1.2403 + _LIT(KTest20,"RWsSession stress EnableWindowSizeCacheL");
1.2404 +
1.2405 + const TDisplayMode displayMode = EColor16MAP;
1.2406 + const TUint KPerformanceIterations = 50000;
1.2407 + const TUint KStressTestIterations = 3000;
1.2408 + const TUint KStressWindowPoolSize = 100;
1.2409 +
1.2410 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
1.2411 +
1.2412 + switch(++iTest->iState)
1.2413 + {
1.2414 +/**
1.2415 +@SYMTestCaseID GRAPHICS-WSERV-0701
1.2416 +
1.2417 +@SYMDEF DevCR BBRE-7UWGHL
1.2418 +
1.2419 +@SYMTestCaseDesc Test creation and destruction for instances of RWindow, window size cache off
1.2420 +
1.2421 +@SYMTestPriority High
1.2422 +
1.2423 +@SYMTestStatus Implemented
1.2424 +
1.2425 +@SYMTestActions Creates an RWsSession, some RWindowGroup and RWindow instances, and closes them.
1.2426 +
1.2427 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2428 +*/
1.2429 + case 1:
1.2430 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0701"));
1.2431 + iTest->LogSubTest(KTest1);
1.2432 + TestCreateRWindowL(ETestSizeCacheNotEnabled);
1.2433 + break;
1.2434 +/**
1.2435 +@SYMTestCaseID GRAPHICS-WSERV-0702
1.2436 +
1.2437 +@SYMDEF DevCR BBRE-7UWGHL
1.2438 +
1.2439 +@SYMTestCaseDesc Test creation and destruction for instances of RWindow, window size cache on
1.2440 +
1.2441 +@SYMTestPriority High
1.2442 +
1.2443 +@SYMTestStatus Implemented
1.2444 +
1.2445 +@SYMTestActions Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, and closes them.
1.2446 +
1.2447 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2448 +*/
1.2449 + case 2:
1.2450 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0702"));
1.2451 + iTest->LogSubTest(KTest2);
1.2452 + TestCreateRWindowL(ETestSizeCacheEnabled);
1.2453 + break;
1.2454 +/**
1.2455 +@SYMTestCaseID GRAPHICS-WSERV-0703
1.2456 +
1.2457 +@SYMDEF DevCR BBRE-7UWGHL
1.2458 +
1.2459 +@SYMTestCaseDesc Test creation and destruction for instances of RBlankWindow, window size cache off
1.2460 +
1.2461 +@SYMTestPriority High
1.2462 +
1.2463 +@SYMTestStatus Implemented
1.2464 +
1.2465 +@SYMTestActions Creates an RWsSession, creates some RWindowGroup and RBlankWindow instances, and closes them.
1.2466 +
1.2467 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2468 +*/
1.2469 + case 3:
1.2470 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0703"));
1.2471 + iTest->LogSubTest(KTest3);
1.2472 + TestCreateRBlankWindowL(ETestSizeCacheNotEnabled);
1.2473 + break;
1.2474 +/**
1.2475 +@SYMTestCaseID GRAPHICS-WSERV-0704
1.2476 +
1.2477 +@SYMDEF DevCR BBRE-7UWGHL
1.2478 +
1.2479 +@SYMTestCaseDesc Test creation and destruction for instances of RBlankWindow, window size cache on
1.2480 +
1.2481 +@SYMTestPriority High
1.2482 +
1.2483 +@SYMTestStatus Implemented
1.2484 +
1.2485 +@SYMTestActions Creates an RWsSession, enables window size cache, creates some RWindowGroup and RBlankWindow instances, and closes them.
1.2486 +
1.2487 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2488 +*/
1.2489 + case 4:
1.2490 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0704"));
1.2491 + iTest->LogSubTest(KTest4);
1.2492 + TestCreateRBlankWindowL(ETestSizeCacheEnabled);
1.2493 + break;
1.2494 +/**
1.2495 +@SYMTestCaseID GRAPHICS-WSERV-0705
1.2496 +
1.2497 +@SYMDEF DevCR BBRE-7UWGHL
1.2498 +
1.2499 +@SYMTestCaseDesc Test creation and destruction for instances of RBackedUpWindow, window size cache off
1.2500 +
1.2501 +@SYMTestPriority High
1.2502 +
1.2503 +@SYMTestStatus Implemented
1.2504 +
1.2505 +@SYMTestActions Creates an RWsSession, creates some RWindowGroup and RBackedUpWindow instances, and closes them.
1.2506 +
1.2507 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2508 +*/
1.2509 + case 5:
1.2510 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0705"));
1.2511 + iTest->LogSubTest(KTest5);
1.2512 + TestCreateRBackedUpWindowL(ETestSizeCacheNotEnabled, displayMode);
1.2513 + break;
1.2514 +/**
1.2515 +@SYMTestCaseID GRAPHICS-WSERV-0706
1.2516 +
1.2517 +@SYMDEF DevCR BBRE-7UWGHL
1.2518 +
1.2519 +@SYMTestCaseDesc Test creation and destruction for instances of RBackedUpWindow, window size cache on
1.2520 +
1.2521 +@SYMTestPriority High
1.2522 +
1.2523 +@SYMTestStatus Implemented
1.2524 +
1.2525 +@SYMTestActions Creates an RWsSession, enables window size cache, creates some RWindowGroup and RBackedUpWindow instances, and closes them.
1.2526 +
1.2527 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2528 +*/
1.2529 + case 6:
1.2530 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0706"));
1.2531 + iTest->LogSubTest(KTest6);
1.2532 + TestCreateRBackedUpWindowL(ETestSizeCacheEnabled, displayMode);
1.2533 + break;
1.2534 +/**
1.2535 +@SYMTestCaseID GRAPHICS-WSERV-0707
1.2536 +
1.2537 +@SYMDEF DevCR BBRE-7UWGHL
1.2538 +
1.2539 +@SYMTestCaseDesc Test RWindow size cache - State: No Cache Entry
1.2540 +
1.2541 +@SYMTestPriority High
1.2542 +
1.2543 +@SYMTestStatus Implemented
1.2544 +
1.2545 +@SYMTestActions Perform the following with window size cache on and off:
1.2546 + Create RWsSession, creates RWindowGroup and RWindow.
1.2547 + Perform one of SetExtent/SetSize/SetExtentErr/SetSizeErr/EnableWindowSizeCacheL.
1.2548 + Clean up.
1.2549 +
1.2550 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2551 +*/
1.2552 + case 7:
1.2553 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0707"));
1.2554 + iTest->LogSubTest(KTest7);
1.2555 + TestRWindowNoCacheEntryL(ETestSizeCacheNotEnabled);
1.2556 + TestRWindowNoCacheEntryL(ETestSizeCacheEnabled);
1.2557 + TestRWindowNoCacheEntrySetExtentErrL(ETestSizeCacheNotEnabled);
1.2558 + TestRWindowNoCacheEntrySetExtentErrL(ETestSizeCacheEnabled);
1.2559 + TestRWindowNoCacheEntrySetSizeErrL(ETestSizeCacheNotEnabled);
1.2560 + TestRWindowNoCacheEntrySetSizeErrL(ETestSizeCacheEnabled);
1.2561 + TestRWindowNoCacheEntrySetExtentL(ETestSizeCacheNotEnabled);
1.2562 + TestRWindowNoCacheEntrySetExtentL(ETestSizeCacheEnabled);
1.2563 + TestRWindowNoCacheEntrySetSizeL(ETestSizeCacheNotEnabled);
1.2564 + TestRWindowNoCacheEntrySetSizeL(ETestSizeCacheEnabled);
1.2565 + TestRWindowNoCacheEntryEnableWindowSizeCacheL();
1.2566 + break;
1.2567 +
1.2568 +/**
1.2569 +@SYMTestCaseID GRAPHICS-WSERV-0708
1.2570 +
1.2571 +@SYMDEF DevCR BBRE-7UWGHL
1.2572 +
1.2573 +@SYMTestCaseDesc Test RWindow size cache State: Cache entry exists, cache clean
1.2574 +
1.2575 +@SYMTestPriority High
1.2576 +
1.2577 +@SYMTestStatus Implemented
1.2578 +
1.2579 +@SYMTestActions Perform the following with window size cache on and off:
1.2580 + Create RWsSession, creates RWindowGroup and RWindow, calls SetSize.
1.2581 + Perform one of Size/EnableWindowSizeCacheL.
1.2582 + Check that size returned matches expected size.
1.2583 + Clean up.
1.2584 +
1.2585 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2586 +*/
1.2587 + case 8:
1.2588 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0708"));
1.2589 + iTest->LogSubTest(KTest8);
1.2590 + TestRWindowCacheEntryExistsCacheCleanL(ETestSizeCacheNotEnabled);
1.2591 + TestRWindowCacheEntryExistsCacheCleanL(ETestSizeCacheEnabled);
1.2592 + TestRWindowCacheEntryExistsCacheCleanSizeL(ETestSizeCacheNotEnabled);
1.2593 + TestRWindowCacheEntryExistsCacheCleanSizeL(ETestSizeCacheEnabled);
1.2594 + TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheL();
1.2595 + TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheLSizeL();
1.2596 + break;
1.2597 +
1.2598 +/**
1.2599 +@SYMTestCaseID GRAPHICS-WSERV-0709
1.2600 +
1.2601 +@SYMDEF DevCR BBRE-7UWGHL
1.2602 +
1.2603 +@SYMTestCaseDesc Test RWindow size cache State: Cache entry exists, cache dirty
1.2604 +
1.2605 +@SYMTestPriority High
1.2606 +
1.2607 +@SYMTestStatus Implemented
1.2608 +
1.2609 +@SYMTestActions Perform the following with window size cache on and off:
1.2610 + Create RWsSession, creates RWindowGroup and RWindow.
1.2611 + Calls SetSize, Size, then SetSize to enter state with dirty cache entry.
1.2612 + Perform combinations of SetSize/SetExtent/SetSizeErr/SetExtentErr/EnableWindowSizeCacheL.
1.2613 + Check that size returned matches the last size set on the window whenever size is queried.
1.2614 + Clean up.
1.2615 +
1.2616 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2617 +*/
1.2618 + case 9:
1.2619 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0709"));
1.2620 + iTest->LogSubTest(KTest9);
1.2621 + TestRWindowCacheEntryExistsCacheDirtySetSizeL(ETestSizeCacheNotEnabled);
1.2622 + TestRWindowCacheEntryExistsCacheDirtySetSizeL(ETestSizeCacheEnabled);
1.2623 + TestRWindowCacheEntryExistsCacheDirtySetExtentL(ETestSizeCacheNotEnabled);
1.2624 + TestRWindowCacheEntryExistsCacheDirtySetExtentL(ETestSizeCacheEnabled);
1.2625 + TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(ETestSizeCacheNotEnabled);
1.2626 + TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(ETestSizeCacheEnabled);
1.2627 + TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(ETestSizeCacheNotEnabled);
1.2628 + TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(ETestSizeCacheEnabled);
1.2629 + TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(ETestSizeCacheNotEnabled);
1.2630 + TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(ETestSizeCacheEnabled);
1.2631 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(ETestSizeCacheNotEnabled);
1.2632 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(ETestSizeCacheEnabled);
1.2633 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(ETestSizeCacheNotEnabled);
1.2634 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(ETestSizeCacheEnabled);
1.2635 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(ETestSizeCacheNotEnabled);
1.2636 + TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(ETestSizeCacheEnabled);
1.2637 + TestRWindowCacheEntryExistsCacheDirtySetSizeEnableWindowSizeCacheL();
1.2638 + break;
1.2639 +
1.2640 +
1.2641 +/**
1.2642 +@SYMTestCaseID GRAPHICS-WSERV-0710
1.2643 +
1.2644 +@SYMDEF DevCR BBRE-7UWGHL
1.2645 +
1.2646 +@SYMTestCaseDesc Test RWindow size cache State: Cache entry exists, cache dirty -> State: Cache entry exists, cache clean
1.2647 +
1.2648 +@SYMTestPriority High
1.2649 +
1.2650 +@SYMTestStatus Implemented
1.2651 +
1.2652 +@SYMTestActions Perform the following with window size cache on and off:
1.2653 + Create RWsSession, creates RWindowGroup and RWindow.
1.2654 + Calls SetSize, Size, to enter state with clean cache entry.
1.2655 + Perform combinations of SetSize/SetExtent/SetSizeErr/SetExtentErr/EnableWindowSizeCacheL to enter state with dirty cache entry.
1.2656 + Calls RWindow::Size to re-enter state with clean cache entry.
1.2657 + Check that size returned matches the last size set on the window whenever size is queried.
1.2658 + Clean up.
1.2659 +
1.2660 +@SYMTestExpectedResults Window objects created successfully, no memory leaks.
1.2661 +*/
1.2662 + case 10:
1.2663 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0710"));
1.2664 + iTest->LogSubTest(KTest10);
1.2665 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(ETestSizeCacheNotEnabled);
1.2666 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(ETestSizeCacheEnabled);
1.2667 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(ETestSizeCacheNotEnabled);
1.2668 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(ETestSizeCacheEnabled);
1.2669 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(ETestSizeCacheNotEnabled);
1.2670 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(ETestSizeCacheEnabled);
1.2671 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(ETestSizeCacheNotEnabled);
1.2672 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(ETestSizeCacheEnabled);
1.2673 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(ETestSizeCacheNotEnabled);
1.2674 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(ETestSizeCacheEnabled);
1.2675 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(ETestSizeCacheNotEnabled);
1.2676 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(ETestSizeCacheEnabled);
1.2677 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(ETestSizeCacheNotEnabled);
1.2678 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(ETestSizeCacheEnabled);
1.2679 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(ETestSizeCacheNotEnabled);
1.2680 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(ETestSizeCacheEnabled);
1.2681 + TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeEnableWindowSizeCacheL();
1.2682 + break;
1.2683 +
1.2684 +/**
1.2685 +@SYMTestCaseID GRAPHICS-WSERV-0711
1.2686 +
1.2687 +@SYMDEF DevCR BBRE-7UWGHL
1.2688 +
1.2689 +@SYMTestCaseDesc Test RBlankWindow Size cache behaviour
1.2690 +
1.2691 +@SYMTestPriority High
1.2692 +
1.2693 +@SYMTestStatus Implemented
1.2694 +
1.2695 +@SYMTestActions Utilises RBlankWindow::SetSize, RBlankWindow::SetExtent, RBlankWindow::Size.
1.2696 + Checks size returned by RBlankWindow::Size.
1.2697 + Cleans up.
1.2698 +
1.2699 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size returned should be last size set on window
1.2700 +*/
1.2701 + case 11:
1.2702 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0711"));
1.2703 + iTest->LogSubTest(KTest11);
1.2704 + TestRBlankWindowSetSizeSetExtentL(ETestSizeCacheNotEnabled);
1.2705 + TestRBlankWindowSetSizeSetExtentL(ETestSizeCacheEnabled);
1.2706 + break;
1.2707 +/**
1.2708 +@SYMTestCaseID GRAPHICS-WSERV-0712
1.2709 +
1.2710 +@SYMDEF DevCR BBRE-7UWGHL
1.2711 +
1.2712 +@SYMTestCaseDesc Test RBackedUpWindow Size cache behaviour
1.2713 +
1.2714 +@SYMTestPriority High
1.2715 +
1.2716 +@SYMTestStatus Implemented
1.2717 +
1.2718 +@SYMTestActions Utilises RBackedUpWindow::SetSizeErr, RBackedUpWindow::SetExtentErr, RBackedUpWindow::Size.
1.2719 + Checks size returned by RBackedUpWindow::Size.
1.2720 + Cleans up.
1.2721 +
1.2722 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size returned should be last size set on window
1.2723 +*/
1.2724 + case 12:
1.2725 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0712"));
1.2726 + iTest->LogSubTest(KTest12);
1.2727 + TestRBackedUpWindowSetSizeErrSetExtentErrL(ETestSizeCacheNotEnabled);
1.2728 + TestRBackedUpWindowSetSizeErrSetExtentErrL(ETestSizeCacheEnabled);
1.2729 + break;
1.2730 +
1.2731 +/**
1.2732 +@SYMTestCaseID GRAPHICS-WSERV-0713
1.2733 +
1.2734 +@SYMDEF DevCR BBRE-7UWGHL
1.2735 +
1.2736 +@SYMTestCaseDesc Compare performance of RWindow::Size function with size cache on and off
1.2737 +
1.2738 +@SYMTestPriority High
1.2739 +
1.2740 +@SYMTestStatus Implemented
1.2741 +
1.2742 +@SYMTestActions Creates an RWsSession, optionally enables window size cache, creates an RWindowGroup and an RWindow
1.2743 + Calls RWindow::Size KPerformanceIterations times.
1.2744 + Measures time taken - with and without size cache enabled
1.2745 +
1.2746 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, time taken for KPerformanceIterations RWindow::Size() calls with cache enabled should be faster.
1.2747 +*/
1.2748 + case 13:
1.2749 + {
1.2750 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0713"));
1.2751 + iTest->LogSubTest(KTest13);
1.2752 + TUint64 sizeCacheOffDeltaMicroSeconds = TestRWindowSizePerformanceL(ETestSizeCacheNotEnabled, KPerformanceIterations);
1.2753 + TUint64 sizeCacheOnDeltaMicroSeconds = TestRWindowSizePerformanceL(ETestSizeCacheEnabled, KPerformanceIterations);
1.2754 + TEST(sizeCacheOnDeltaMicroSeconds < sizeCacheOffDeltaMicroSeconds);
1.2755 + INFO_PRINTF1(_L("Accessing size using cache is faster"));
1.2756 + }
1.2757 + break;
1.2758 +/**
1.2759 +@SYMTestCaseID GRAPHICS-WSERV-0714
1.2760 +
1.2761 +@SYMDEF DevCR BBRE-7UWGHL
1.2762 +
1.2763 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions
1.2764 +
1.2765 +@SYMTestPriority High
1.2766 +
1.2767 +@SYMTestStatus Implemented
1.2768 +
1.2769 +@SYMTestActions Creates an RWsSession, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2770 +
1.2771 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2772 +*/
1.2773 + case 14:
1.2774 + {
1.2775 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0714"));
1.2776 + iTest->LogSubTest(KTest14);
1.2777 + TInt seed = Math::Random();
1.2778 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2779 + SetRandomSeed(seed);
1.2780 + TestRandomisedStressL(ETestSizeCacheNotEnabled, KStressTestIterations);
1.2781 + }
1.2782 + break;
1.2783 +/**
1.2784 +@SYMTestCaseID GRAPHICS-WSERV-0714
1.2785 +
1.2786 +@SYMDEF DevCR BBRE-7UWGHL
1.2787 +
1.2788 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions, size cache on
1.2789 +
1.2790 +@SYMTestPriority High
1.2791 +
1.2792 +@SYMTestStatus Implemented
1.2793 +
1.2794 +@SYMTestActions Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2795 +
1.2796 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2797 +*/
1.2798 + case 15:
1.2799 + {
1.2800 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0715"));
1.2801 + iTest->LogSubTest(KTest15);
1.2802 + TInt seed = Math::Random();
1.2803 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2804 + SetRandomSeed(seed);
1.2805 + TestRandomisedStressL(ETestSizeCacheEnabled, KStressTestIterations);
1.2806 + }
1.2807 + break;
1.2808 +
1.2809 +
1.2810 +/**
1.2811 +@SYMTestCaseID GRAPHICS-WSERV-0716
1.2812 +
1.2813 +@SYMDEF DevCR BBRE-7UWGHL
1.2814 +
1.2815 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions, multiple sessions
1.2816 +
1.2817 +@SYMTestPriority High
1.2818 +
1.2819 +@SYMTestStatus Implemented
1.2820 +
1.2821 +@SYMTestActions Creates two RWsSession instances, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2822 +
1.2823 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2824 +*/
1.2825 + case 16:
1.2826 + {
1.2827 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0716"));
1.2828 + iTest->LogSubTest(KTest16);
1.2829 + TInt seed = Math::Random();
1.2830 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2831 + SetRandomSeed(seed);
1.2832 + TestRandomisedStressMultiSessionL(ETestSizeCacheNotEnabled, KStressTestIterations);
1.2833 + }
1.2834 + break;
1.2835 +/**
1.2836 +@SYMTestCaseID GRAPHICS-WSERV-0717
1.2837 +
1.2838 +@SYMDEF DevCR BBRE-7UWGHL
1.2839 +
1.2840 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions, multiple sessions, size cache on
1.2841 +
1.2842 +@SYMTestPriority High
1.2843 +
1.2844 +@SYMTestStatus Implemented
1.2845 +
1.2846 +@SYMTestActions Creates two RWsSession instances, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2847 +
1.2848 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2849 +*/
1.2850 + case 17:
1.2851 + {
1.2852 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0717"));
1.2853 + iTest->LogSubTest(KTest17);
1.2854 + TInt seed = Math::Random();
1.2855 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2856 + SetRandomSeed(seed);
1.2857 + TestRandomisedStressMultiSessionL(ETestSizeCacheEnabled, KStressTestIterations);
1.2858 + }
1.2859 + break;
1.2860 +
1.2861 +/**
1.2862 +@SYMTestCaseID GRAPHICS-WSERV-0718
1.2863 +
1.2864 +@SYMDEF DevCR BBRE-7UWGHL
1.2865 +
1.2866 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions, large number of windows
1.2867 +
1.2868 +@SYMTestPriority High
1.2869 +
1.2870 +@SYMTestStatus Implemented
1.2871 +
1.2872 +@SYMTestActions Creates an RWsSession, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2873 +
1.2874 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2875 +*/
1.2876 + case 18:
1.2877 + {
1.2878 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0718"));
1.2879 + iTest->LogSubTest(KTest18);
1.2880 + TInt seed = Math::Random();
1.2881 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2882 + SetRandomSeed(seed);
1.2883 + TestRandomisedStressCacheEntryVolumeL(ETestSizeCacheNotEnabled, KStressTestIterations, KStressWindowPoolSize);
1.2884 + }
1.2885 + break;
1.2886 +/**
1.2887 +@SYMTestCaseID GRAPHICS-WSERV-0719
1.2888 +
1.2889 +@SYMDEF DevCR BBRE-7UWGHL
1.2890 +
1.2891 +@SYMTestCaseDesc Randomised stress test - RWindow size related functions, large number of windows
1.2892 +
1.2893 +@SYMTestPriority High
1.2894 +
1.2895 +@SYMTestStatus Implemented
1.2896 +
1.2897 +@SYMTestActions Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.
1.2898 +
1.2899 +@SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window
1.2900 +*/
1.2901 + case 19:
1.2902 + {
1.2903 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0719"));
1.2904 + iTest->LogSubTest(KTest19);
1.2905 + TInt seed = Math::Random();
1.2906 + // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed
1.2907 + SetRandomSeed(seed);
1.2908 + TestRandomisedStressCacheEntryVolumeL(ETestSizeCacheEnabled, KStressTestIterations, KStressWindowPoolSize);
1.2909 + }
1.2910 + break;
1.2911 +
1.2912 +/**
1.2913 +@SYMTestCaseID GRAPHICS-WSERV-0720
1.2914 +
1.2915 +@SYMDEF DevCR BBRE-7UWGHL
1.2916 +
1.2917 +@SYMTestCaseDesc Test RWsSession::EnableWindowSizeCacheL() API
1.2918 +
1.2919 +@SYMTestPriority High
1.2920 +
1.2921 +@SYMTestStatus Implemented
1.2922 +
1.2923 +@SYMTestActions Creates an RWsSession, calls EnableWindowSizeCacheL() multiple times, uses Size related APIs.
1.2924 +
1.2925 +@SYMTestExpectedResults No memory leaks.
1.2926 +*/
1.2927 + case 20:
1.2928 + {
1.2929 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0720"));
1.2930 + iTest->LogSubTest(KTest20);
1.2931 + TestStressEnableWindowSizeCacheL(KStressTestIterations);
1.2932 + }
1.2933 + break;
1.2934 + default:
1.2935 + ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
1.2936 + ((CTWindowSizeCacheTestStep*)iStep)->CloseTMSGraphicsStep();
1.2937 + TestComplete();
1.2938 + break;
1.2939 + }
1.2940 + ((CTWindowSizeCacheTestStep*)iStep)->RecordTestResultL();
1.2941 + }
1.2942 +
1.2943 +__WS_CONSTRUCT_STEP__(WindowSizeCacheTest)