31     }

    31     }

    32 

    32 

    33 void CTWindowSizeCacheTest::ConstructL()

    33 void CTWindowSizeCacheTest::ConstructL()

    34     {}

    34     {}

    35 

    35 

    37 void CTWindowSizeCacheTest::TestCreateRWindowL(TSizeCacheStatus aEnableWindowSizeCache)

    36 void CTWindowSizeCacheTest::TestCreateRWindowL(TSizeCacheStatus aEnableWindowSizeCache)

    38     {

    37     {

    39     __UHEAP_MARK;

    38     __UHEAP_MARK;

    40     // w* State Initial

    39     // w* State Initial

    41     RWsSession rws;

    40     RWsSession rws;

   577     rws.Flush();

   576     rws.Flush();

   578     

   577     

   579     // w1 State 1

   578     // w1 State 1

   580     TSize retSize1 = w1.Size();

   579     TSize retSize1 = w1.Size();

   581     TEST(retSize1 == size1);

   580     TEST(retSize1 == size1);

   583     // w1 State Final

   587     // w1 State Final

   584     CleanupStack::Pop();

   588     CleanupStack::Pop();

   585     w1.Close();

   589     w1.Close();

   586     

   590     

   587     CleanupStack::Pop();

   591     CleanupStack::Pop();

   622     rws.Flush();

   626     rws.Flush();

   623     

   627     

   624     // w1 State 1

   628     // w1 State 1

   625     TSize retSize1 = w1.Size();

   629     TSize retSize1 = w1.Size();

   626     TEST(retSize1 == size1);

   630     TEST(retSize1 == size1);

   628     // w1 State 1

   637     // w1 State 1

   629     TSize retSize2 = w1.Size();

   638     TSize retSize2 = w1.Size();

   630     TEST(retSize2 == size1);

   639     TEST(retSize2 == size1);

   631 

   640 

   632     // w1 State Final

   646     // w1 State Final

   633     CleanupStack::Pop();

   647     CleanupStack::Pop();

   634     w1.Close();

   648     w1.Close();

   635     

   649     

   636     CleanupStack::Pop();

   650     CleanupStack::Pop();

   668     rws.Flush();

   682     rws.Flush();

   669     

   683     

   670     // w1 State 1

   684     // w1 State 1

   671     TSize retSize1 = w1.Size();

   685     TSize retSize1 = w1.Size();

   672     TEST(retSize1 == size1);

   686     TEST(retSize1 == size1);

   674     // w1 State 1

   693     // w1 State 1

   675     // Only the first call to EnableWindowSizeCacheL() should have an effect

   694     // Only the first call to EnableWindowSizeCacheL() should have an effect

   676     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   695     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   677     rws.EnableWindowSizeCacheL();

   696     rws.EnableWindowSizeCacheL();

   678 

   697 

   715     rws.Flush();

   734     rws.Flush();

   716     

   735     

   717     // w1 State 1

   736     // w1 State 1

   718     TSize retSize1 = w1.Size();

   737     TSize retSize1 = w1.Size();

   719     TEST(retSize1 == size1);

   738     TEST(retSize1 == size1);

   720     

   744     

   721     // w1 State 1

   745     // w1 State 1

   722     // Only the first call to EnableWindowSizeCacheL() should have an effect

   746     // Only the first call to EnableWindowSizeCacheL() should have an effect

   723     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   747     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   724     rws.EnableWindowSizeCacheL();

   748     rws.EnableWindowSizeCacheL();

   725 

   749 

   726     // w1 State 1

   750     // w1 State 1

   727     TSize retSize2 = w1.Size();

   751     TSize retSize2 = w1.Size();

   728     TEST(retSize2 == size1);

   752     TEST(retSize2 == size1);

   729 

   753 

   730     // w1 State Final

   759     // w1 State Final

   731     CleanupStack::Pop();

   760     CleanupStack::Pop();

   732     w1.Close();

   761     w1.Close();

   733     

   762     

   734     CleanupStack::Pop();

   763     CleanupStack::Pop();

   769     rws.Flush();

   798     rws.Flush();

   770     

   799     

   771     // w1 State 1

   800     // w1 State 1

   772     TSize retSize1 = w1.Size();

   801     TSize retSize1 = w1.Size();

   773     TEST(retSize1 == size1);

   802     TEST(retSize1 == size1);

   774     

   808     

   775     // w1 State 2

   809     // w1 State 2

   776     TSize size2 (20002,223);

   810     TSize size2 (20002,223);

   777     w1.SetSize(size2); 

   811     w1.SetSize(size2); 

   778     rws.Flush();

   812     rws.Flush();

   819     rws.Flush();

   853     rws.Flush();

   820     

   854     

   821     // w1 State 1

   855     // w1 State 1

   822     TSize retSize1 = w1.Size();

   856     TSize retSize1 = w1.Size();

   823     TEST(retSize1 == size1);

   857     TEST(retSize1 == size1);

   824     

   863     

   825     // w1 State 2

   864     // w1 State 2

   826     TPoint point2 (20202,223);

   865     TPoint point2 (20202,223);

   827     TSize size2 (20002,223);

   866     TSize size2 (20002,223);

   828     w1.SetExtent(point2, size2); 

   867     w1.SetExtent(point2, size2); 

   870     rws.Flush();

   909     rws.Flush();

   871     

   910     

   872     // w1 State 1

   911     // w1 State 1

   873     TSize retSize1 = w1.Size();

   912     TSize retSize1 = w1.Size();

   874     TEST(retSize1 == size1);

   913     TEST(retSize1 == size1);

   875     

   919     

   876     // w1 State 2

   920     // w1 State 2

   877     TSize size2 (20002,223);

   921     TSize size2 (20002,223);

   878     err = w1.SetSizeErr(size2); 

   922     err = w1.SetSizeErr(size2); 

   879     TEST(KErrNone == err);

   923     TEST(KErrNone == err);

   920     rws.Flush();

   964     rws.Flush();

   921     

   965     

   922     // w1 State 1

   966     // w1 State 1

   923     TSize retSize1 = w1.Size();

   967     TSize retSize1 = w1.Size();

   924     TEST(retSize1 == size1);

   968     TEST(retSize1 == size1);

   925     

   974     

   926     // w1 State 2

   975     // w1 State 2

   927     TPoint point2 (20202,223);

   976     TPoint point2 (20202,223);

   928     TSize size2 (20002,223);

   977     TSize size2 (20002,223);

   929     err = w1.SetExtentErr(point2, size2); 

   978     err = w1.SetExtentErr(point2, size2); 

   971     rws.Flush();

  1020     rws.Flush();

   972     

  1021     

   973     // w1 State 1

  1022     // w1 State 1

   974     TSize retSize1 = w1.Size();

  1023     TSize retSize1 = w1.Size();

   975     TEST(retSize1 == size1);

  1024     TEST(retSize1 == size1);

   976     

  1030     

   977     // w1 State 2

  1031     // w1 State 2

   978     TSize size2 (20002,223);

  1032     TSize size2 (20002,223);

   979     w1.SetSize(size2); 

  1033     w1.SetSize(size2); 

   980 

  1034 

  1025     rws.Flush();

  1079     rws.Flush();

  1026     

  1080     

  1027     // w1 State 1

  1081     // w1 State 1

  1028     TSize retSize1 = w1.Size();

  1082     TSize retSize1 = w1.Size();

  1029     TEST(retSize1 == size1);

  1083     TEST(retSize1 == size1);

  1030     

  1089     

  1031     // w1 State 2

  1090     // w1 State 2

  1032     TSize size2 (20002,223);

  1091     TSize size2 (20002,223);

  1033     w1.SetSize(size2); 

  1092     w1.SetSize(size2); 

  1034 

  1093 

  1080     rws.Flush();

  1139     rws.Flush();

  1081     

  1140     

  1082     // w1 State 1

  1141     // w1 State 1

  1083     TSize retSize1 = w1.Size();

  1142     TSize retSize1 = w1.Size();

  1084     TEST(retSize1 == size1);

  1143     TEST(retSize1 == size1);

  1085     

  1149     

  1086     // w1 State 2

  1150     // w1 State 2

  1087     TSize size2 (20002,223);

  1151     TSize size2 (20002,223);

  1088     w1.SetSize(size2); 

  1152     w1.SetSize(size2); 

  1089 

  1153 

  1134     rws.Flush();

  1198     rws.Flush();

  1135     

  1199     

  1136     // w1 State 1

  1200     // w1 State 1

  1137     TSize retSize1 = w1.Size();

  1201     TSize retSize1 = w1.Size();

  1138     TEST(retSize1 == size1);

  1202     TEST(retSize1 == size1);

  1139     

  1208     

  1140     // w1 State 2

  1209     // w1 State 2

  1141     TSize size2 (20002,223);

  1210     TSize size2 (20002,223);

  1142     w1.SetSize(size2); 

  1211     w1.SetSize(size2); 

  1143 

  1212 

  1186     rws.Flush();

  1255     rws.Flush();

  1187     

  1256     

  1188     // w1 State 1

  1257     // w1 State 1

  1189     TSize retSize1 = w1.Size();

  1258     TSize retSize1 = w1.Size();

  1190     TEST(retSize1 == size1);

  1259     TEST(retSize1 == size1);

  1191     

  1265     

  1192     // w1 State 2

  1266     // w1 State 2

  1193     TSize size2 (20002,223);

  1267     TSize size2 (20002,223);

  1194     w1.SetSize(size2); 

  1268     w1.SetSize(size2); 

  1195 

  1269 

  1240     rws.Flush();

  1314     rws.Flush();

  1241     

  1315     

  1242     // w1 State 1

  1316     // w1 State 1

  1243     TSize retSize1 = w1.Size();

  1317     TSize retSize1 = w1.Size();

  1244     TEST(retSize1 == size1);

  1318     TEST(retSize1 == size1);

  1245     

  1324     

  1246     // w1 State 2

  1325     // w1 State 2

  1247     TSize size2 (20002,223);

  1326     TSize size2 (20002,223);

  1248     w1.SetSize(size2); 

  1327     w1.SetSize(size2); 

  1249     rws.Flush();

  1328     rws.Flush();

  1250 

  1329 

  1251     // w1 State 1

  1330     // w1 State 1

  1252     TSize retSize2 = w1.Size();

  1331     TSize retSize2 = w1.Size();

  1253     TEST(retSize2 == size2);

  1332     TEST(retSize2 == size2);

  1254 

  1333 

  1255     // w1 State Final

  1339     // w1 State Final

  1256     CleanupStack::Pop();

  1340     CleanupStack::Pop();

  1257     w1.Close();

  1341     w1.Close();

  1258     

  1342     

  1259     CleanupStack::Pop();

  1343     CleanupStack::Pop();

  1294     rws.Flush();

  1378     rws.Flush();

  1295     

  1379     

  1296     // w1 State 1

  1380     // w1 State 1

  1297     TSize retSize1 = w1.Size();

  1381     TSize retSize1 = w1.Size();

  1298     TEST(retSize1 == size1);

  1382     TEST(retSize1 == size1);

  1299     

  1388     

  1300     // w1 State 2

  1389     // w1 State 2

  1301     TPoint point2 (20202,223);

  1390     TPoint point2 (20202,223);

  1302     TSize size2 (20002,223);

  1391     TSize size2 (20002,223);

  1303     w1.SetExtent(point2, size2); 

  1392     w1.SetExtent(point2, size2); 

  1305 

  1394 

  1306     // w1 State 1

  1395     // w1 State 1

  1307     TSize retSize2 = w1.Size();

  1396     TSize retSize2 = w1.Size();

  1308     TEST(retSize2 == size2);

  1397     TEST(retSize2 == size2);

  1309 

  1398 

  1310     // w1 State Final

  1404     // w1 State Final

  1311     CleanupStack::Pop();

  1405     CleanupStack::Pop();

  1312     w1.Close();

  1406     w1.Close();

  1313     

  1407     

  1314     CleanupStack::Pop();

  1408     CleanupStack::Pop();

  1349     rws.Flush();

  1443     rws.Flush();

  1350     

  1444     

  1351     // w1 State 1

  1445     // w1 State 1

  1352     TSize retSize1 = w1.Size();

  1446     TSize retSize1 = w1.Size();

  1353     TEST(retSize1 == size1);

  1447     TEST(retSize1 == size1);

  1354     

  1453     

  1355     // w1 State 2

  1454     // w1 State 2

  1356     TSize size2 (20002,223);

  1455     TSize size2 (20002,223);

  1357     err = w1.SetSizeErr(size2); 

  1456     err = w1.SetSizeErr(size2); 

  1358     TEST(KErrNone == err);

  1457     TEST(KErrNone == err);

  1359 

  1458 

  1360     // w1 State 1

  1459     // w1 State 1

  1361     TSize retSize2 = w1.Size();

  1460     TSize retSize2 = w1.Size();

  1362     TEST(retSize2 == size2);

  1461     TEST(retSize2 == size2);

  1363 

  1462 

  1364     // w1 State Final

  1468     // w1 State Final

  1365     CleanupStack::Pop();

  1469     CleanupStack::Pop();

  1366     w1.Close();

  1470     w1.Close();

  1367     

  1471     

  1368     CleanupStack::Pop();

  1472     CleanupStack::Pop();

  1403     rws.Flush();

  1507     rws.Flush();

  1404     

  1508     

  1405     // w1 State 1

  1509     // w1 State 1

  1406     TSize retSize1 = w1.Size();

  1510     TSize retSize1 = w1.Size();

  1407     TEST(retSize1 == size1);

  1511     TEST(retSize1 == size1);

  1408     

  1517     

  1409     // w1 State 2

  1518     // w1 State 2

  1410     TPoint point2 (20202,223);

  1519     TPoint point2 (20202,223);

  1411     TSize size2 (20002,223);

  1520     TSize size2 (20002,223);

  1412     err = w1.SetExtentErr(point2, size2); 

  1521     err = w1.SetExtentErr(point2, size2); 

  1414 

  1523 

  1415     // w1 State 1

  1524     // w1 State 1

  1416     TSize retSize2 = w1.Size();

  1525     TSize retSize2 = w1.Size();

  1417     TEST(retSize2 == size2);

  1526     TEST(retSize2 == size2);

  1418 

  1527 

  1419     // w1 State Final

  1533     // w1 State Final

  1420     CleanupStack::Pop();

  1534     CleanupStack::Pop();

  1421     w1.Close();

  1535     w1.Close();

  1422     

  1536     

  1423     CleanupStack::Pop();

  1537     CleanupStack::Pop();

  1458     rws.Flush();

  1572     rws.Flush();

  1459     

  1573     

  1460     // w1 State 1

  1574     // w1 State 1

  1461     TSize retSize1 = w1.Size();

  1575     TSize retSize1 = w1.Size();

  1462     TEST(retSize1 == size1);

  1576     TEST(retSize1 == size1);

  1463     

  1582     

  1464     // w1 State 2

  1583     // w1 State 2

  1465     TSize size2 (20002,223);

  1584     TSize size2 (20002,223);

  1466     w1.SetSize(size2); 

  1585     w1.SetSize(size2); 

  1467 

  1586 

  1472 

  1591 

  1473     // w1 State 1

  1592     // w1 State 1

  1474     TSize retSize2 = w1.Size();

  1593     TSize retSize2 = w1.Size();

  1475     TEST(retSize2 == size3);

  1594     TEST(retSize2 == size3);

  1476 

  1595 

  1477     // w1 State Final

  1601     // w1 State Final

  1478     CleanupStack::Pop();

  1602     CleanupStack::Pop();

  1479     w1.Close();

  1603     w1.Close();

  1480     

  1604     

  1481     CleanupStack::Pop();

  1605     CleanupStack::Pop();

  1516     rws.Flush();

  1640     rws.Flush();

  1517     

  1641     

  1518     // w1 State 1

  1642     // w1 State 1

  1519     TSize retSize1 = w1.Size();

  1643     TSize retSize1 = w1.Size();

  1520     TEST(retSize1 == size1);

  1644     TEST(retSize1 == size1);

  1521     

  1650     

  1522     // w1 State 2

  1651     // w1 State 2

  1523     TSize size2 (20002,223);

  1652     TSize size2 (20002,223);

  1524     w1.SetSize(size2); 

  1653     w1.SetSize(size2); 

  1525 

  1654 

  1531 

  1660 

  1532     // w1 State 1

  1661     // w1 State 1

  1533     TSize retSize2 = w1.Size();

  1662     TSize retSize2 = w1.Size();

  1534     TEST(retSize2 == size3);

  1663     TEST(retSize2 == size3);

  1535 

  1664 

  1536     // w1 State Final

  1670     // w1 State Final

  1537     CleanupStack::Pop();

  1671     CleanupStack::Pop();

  1538     w1.Close();

  1672     w1.Close();

  1539     

  1673     

  1540     CleanupStack::Pop();

  1674     CleanupStack::Pop();

  1575     rws.Flush();

  1709     rws.Flush();

  1576     

  1710     

  1577     // w1 State 1

  1711     // w1 State 1

  1578     TSize retSize1 = w1.Size();

  1712     TSize retSize1 = w1.Size();

  1579     TEST(retSize1 == size1);

  1713     TEST(retSize1 == size1);

  1580     

  1719     

  1581     // w1 State 2

  1720     // w1 State 2

  1582     TSize size2 (20002,223);

  1721     TSize size2 (20002,223);

  1583     w1.SetSize(size2); 

  1722     w1.SetSize(size2); 

  1584 

  1723 

  1589 

  1728 

  1590     // w1 State 1

  1729     // w1 State 1

  1591     TSize retSize2 = w1.Size();

  1730     TSize retSize2 = w1.Size();

  1592     TEST(retSize2 == size3);

  1731     TEST(retSize2 == size3);

  1593 

  1732 

  1594     // w1 State Final

  1738     // w1 State Final

  1595     CleanupStack::Pop();

  1739     CleanupStack::Pop();

  1596     w1.Close();

  1740     w1.Close();

  1597     

  1741     

  1598     CleanupStack::Pop();

  1742     CleanupStack::Pop();

  1633     rws.Flush();

  1777     rws.Flush();

  1634     

  1778     

  1635     // w1 State 1

  1779     // w1 State 1

  1636     TSize retSize1 = w1.Size();

  1780     TSize retSize1 = w1.Size();

  1637     TEST(retSize1 == size1);

  1781     TEST(retSize1 == size1);

  1638     

  1787     

  1639     // w1 State 2

  1788     // w1 State 2

  1640     TSize size2 (20002,223);

  1789     TSize size2 (20002,223);

  1641     w1.SetSize(size2); 

  1790     w1.SetSize(size2); 

  1642 

  1791 

  1648 

  1797 

  1649     // w1 State 1

  1798     // w1 State 1

  1650     TSize retSize2 = w1.Size();

  1799     TSize retSize2 = w1.Size();

  1651     TEST(retSize2 == size3);

  1800     TEST(retSize2 == size3);

  1652 

  1801 

  1653     // w1 State Final

  1807     // w1 State Final

  1654     CleanupStack::Pop();

  1808     CleanupStack::Pop();

  1655     w1.Close();

  1809     w1.Close();

  1656     

  1810     

  1657     CleanupStack::Pop();

  1811     CleanupStack::Pop();

  1689     rws.Flush();

  1843     rws.Flush();

  1690     

  1844     

  1691     // w1 State 1

  1845     // w1 State 1

  1692     TSize retSize1 = w1.Size();

  1846     TSize retSize1 = w1.Size();

  1693     TEST(retSize1 == size1);

  1847     TEST(retSize1 == size1);

  1694     

  1853     

  1695     // w1 State 2

  1854     // w1 State 2

  1696     TSize size2 (20002,223);

  1855     TSize size2 (20002,223);

  1697     w1.SetSize(size2); 

  1856     w1.SetSize(size2); 

  1698 

  1857 

  1702 

  1861 

  1703     // w1 State 1

  1862     // w1 State 1

  1704     TSize retSize2 = w1.Size();

  1863     TSize retSize2 = w1.Size();

  1705     TEST(retSize2 == size2);

  1864     TEST(retSize2 == size2);

  1706 

  1865 

  1707     // w1 State Final

  1871     // w1 State Final

  1708     CleanupStack::Pop();

  1872     CleanupStack::Pop();

  1709     w1.Close();

  1873     w1.Close();

  1710     

  1874     

  1711     CleanupStack::Pop();

  1875     CleanupStack::Pop();

  1750     rws.Flush();

  1914     rws.Flush();

  1751     

  1915     

  1752     // w1 State 1

  1916     // w1 State 1

  1753     TSize retSize1 = w1.Size();

  1917     TSize retSize1 = w1.Size();

  1754     TEST(retSize1 == size1);

  1918     TEST(retSize1 == size1);

  1755     

  1924     

  1756     // w1 State 2

  1925     // w1 State 2

  1757     TSize size2 (20002,223);

  1926     TSize size2 (20002,223);

  1758     w1.SetSize(size2); 

  1927     w1.SetSize(size2); 

  1759 

  1928 

  1765 

  1934 

  1766     // w1 State 1

  1935     // w1 State 1

  1767     TSize retSize2 = w1.Size();

  1936     TSize retSize2 = w1.Size();

  1768     TEST(retSize2 == size3);

  1937     TEST(retSize2 == size3);

  1769 

  1938 

  1770     // w1 State 2

  1944     // w1 State 2

  1771     TSize size4 (40004,423);

  1945     TSize size4 (40004,423);

  1772     w1.SetSize(size4);

  1946     w1.SetSize(size4);

  1773     

  1947     

  1774     // w1 State 1

  1948     // w1 State 1

  1775     TSize retSize3 = w1.Size();

  1949     TSize retSize3 = w1.Size();

  1776     TEST(retSize3 == size4);

  1950     TEST(retSize3 == size4);

  1777 

  1951 

  1778     // w1 State Final

  1957     // w1 State Final

  1779     CleanupStack::Pop();

  1958     CleanupStack::Pop();

  1780     w1.Close();

  1959     w1.Close();

  1781     

  1960     

  1782     CleanupStack::Pop();

  1961     CleanupStack::Pop();

  1821     TEST(err==KErrNone);

  2000     TEST(err==KErrNone);

  1822     

  2001     

  1823     // w1 State 1

  2002     // w1 State 1

  1824     TSize retSize1 = w1.Size();

  2003     TSize retSize1 = w1.Size();

  1825     TEST(retSize1 == size1);

  2004     TEST(retSize1 == size1);

  1826     

  2010     

  1827     // w1 State 2

  2011     // w1 State 2

  1828     TSize size2 (20002,223);

  2012     TSize size2 (20002,223);

  1829     err = w1.SetSizeErr(size2); 

  2013     err = w1.SetSizeErr(size2); 

  1830     TEST(err==KErrNone);

  2014     TEST(err==KErrNone);

  1837 

  2021 

  1838     // w1 State 1

  2022     // w1 State 1

  1839     TSize retSize2 = w1.Size();

  2023     TSize retSize2 = w1.Size();

  1840     TEST(retSize2 == size3);

  2024     TEST(retSize2 == size3);

  1841 

  2025 

  1842     // w1 State 2

  2031     // w1 State 2

  1843     TSize size4 (40004,423);

  2032     TSize size4 (40004,423);

  1844     err = w1.SetSizeErr(size4);

  2033     err = w1.SetSizeErr(size4);

  1845     TEST(err==KErrNone);

  2034     TEST(err==KErrNone);

  1846     

  2035     

  1847     // w1 State 1

  2036     // w1 State 1

  1848     TSize retSize3 = w1.Size();

  2037     TSize retSize3 = w1.Size();

  1849     TEST(retSize3 == size4);

  2038     TEST(retSize3 == size4);

  1850 

  2039 

  1851     // w1 State Final

  2045     // w1 State Final

  1852     CleanupStack::Pop();

  2046     CleanupStack::Pop();

  1853     w1.Close();

  2047     w1.Close();

  1854     

  2048     

  1855     CleanupStack::Pop();

  2049     CleanupStack::Pop();

  1899     for (TUint iter = 0; iter < aIterations; ++iter)

  2093     for (TUint iter = 0; iter < aIterations; ++iter)

  1900         {

  2094         {

  1901         // w1 State 1

  2095         // w1 State 1

  1902         TSize retSize1 = w1.Size();

  2096         TSize retSize1 = w1.Size();

  1903         TEST(retSize1 == size1);

  2097         TEST(retSize1 == size1);

  1904         }

  2103         }

  1905     end.UniversalTime();

  2104     end.UniversalTime();

  1906 

  2105 

  1907     TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(start);

  2106     TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(start);

  1908     timeDeltaMicroSeconds = delta.Int64();

  2107     timeDeltaMicroSeconds = delta.Int64();

  1987             break;

  2186             break;

  1988         case ECheckSize :

  2187         case ECheckSize :

  1989             {

  2188             {

  1990             TSize retSize1 = aWindow.Size();

  2189             TSize retSize1 = aWindow.Size();

  1991             TEST(retSize1 == aExpectedSize);

  2190             TEST(retSize1 == aExpectedSize);

  1992             }

  2196             }

  1993             break;

  2197             break;

  1994         case EFlushSession :

  2198         case EFlushSession :

  1995             {

  2199             {

  1996             aWs.Flush();

  2200             aWs.Flush();

  2136         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2340         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2137         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2341         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2138         rws1_expectedSizePool.AppendL(expectedSize);

  2342         rws1_expectedSizePool.AppendL(expectedSize);

  2139         TSize retSize1 = win->Size();

  2343         TSize retSize1 = win->Size();

  2140         TEST(retSize1 == expectedSize);

  2344         TEST(retSize1 == expectedSize);

  2141         }

  2350         }

  2142 

  2351 

  2143     // Windows for session 2 belonging to rws2_wg1

  2352     // Windows for session 2 belonging to rws2_wg1

  2144     // Many windows - siblings

  2353     // Many windows - siblings

  2145     for (TUint iter = 0; iter < KWindowCount_rws2_wg1; ++iter)

  2354     for (TUint iter = 0; iter < KWindowCount_rws2_wg1; ++iter)

  2156         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2365         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2157         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2366         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2158         rws2_expectedSizePool.AppendL(expectedSize);

  2367         rws2_expectedSizePool.AppendL(expectedSize);

  2159         TSize retSize1 = win->Size();

  2368         TSize retSize1 = win->Size();

  2160         TEST(retSize1 == expectedSize);

  2369         TEST(retSize1 == expectedSize);

  2161         }

  2375         }

  2162     

  2376     

  2163     // Windows for session 2 belonging to rws2_wg2

  2377     // Windows for session 2 belonging to rws2_wg2

  2164     // Many windows - children

  2378     // Many windows - children

  2165     RWindowTreeNode parent = rws2_wg2; 

  2379     RWindowTreeNode parent = rws2_wg2; 

  2178         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2392         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2179         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2393         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2180         rws2_expectedSizePool.AppendL(expectedSize);

  2394         rws2_expectedSizePool.AppendL(expectedSize);

  2181         TSize retSize1 = win->Size();

  2395         TSize retSize1 = win->Size();

  2182         TEST(retSize1 == expectedSize);

  2396         TEST(retSize1 == expectedSize);

  2183         }

  2402         }

  2184 

  2403 

  2185     // Stress system by performing actions on windows

  2404     // Stress system by performing actions on windows

  2186     for (TUint iter = 0; iter < aIterations; ++iter)

  2405     for (TUint iter = 0; iter < aIterations; ++iter)

  2187         {

  2406         {

  2263         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2482         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2264         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2483         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2265         expectedSizePool.AppendL(expectedSize);

  2484         expectedSizePool.AppendL(expectedSize);

  2266         TSize retSize1 = win->Size();

  2485         TSize retSize1 = win->Size();

  2267         TEST(retSize1 == expectedSize);

  2486         TEST(retSize1 == expectedSize);

  2268         }

  2492         }

  2269 

  2493 

  2270     // Stress system by performing actions on windows

  2494     // Stress system by performing actions on windows

  2271     for (TUint iter = 0; iter < aIterations; ++iter)

  2495     for (TUint iter = 0; iter < aIterations; ++iter)

  2272         {

  2496         {

  2318 

  2542 

  2319     // w1 State 1

  2543     // w1 State 1

  2320     TSize retSize1 = w1.Size();

  2544     TSize retSize1 = w1.Size();

  2321     TEST(retSize1 == size1);

  2545     TEST(retSize1 == size1);

  2322 

  2546 

  2323     // w1 State 2

  2552     // w1 State 2

  2324     TSize size2 (20002,223);

  2553     TSize size2 (20002,223);

  2325     w1.SetSize(size2); 

  2554     w1.SetSize(size2); 

  2326 

  2555 

  2327     // w1 State 2

  2556     // w1 State 2

  2334    

  2563    

  2335     // w1 State 1

  2564     // w1 State 1

  2336     TSize retSize2 = w1.Size();

  2565     TSize retSize2 = w1.Size();

  2337     TEST(retSize2 == size2);

  2566     TEST(retSize2 == size2);

  2338 

  2567 

  2339     // w1 State Final

  2573     // w1 State Final

  2340     CleanupStack::Pop();

  2574     CleanupStack::Pop();

  2341     w1.Close();

  2575     w1.Close();

  2342     

  2576     

  2343     CleanupStack::Pop();

  2577     CleanupStack::Pop();