ivi-layermanagement-api/test/ilm_control_test.cpp

   1 /***************************************************************************
   2  *
   3  * Copyright 2010-2014 BMW Car IT GmbH
   4  * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *        http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ****************************************************************************/
  20
  21 #include <gtest/gtest.h>
  22 #include <stdio.h>
  23 #include "TestBase.h"
  24
  25 extern "C" {
  26     #include "ilm_client.h"
  27     #include "ilm_control.h"
  28 }
  29
  30 class IlmCommandTest : public TestBase, public ::testing::Test {
  31 public:
  32     void SetUp()
  33     {
  34         ASSERT_EQ(ILM_SUCCESS, ilm_initWithNativedisplay((t_ilm_nativedisplay)wlDisplay));
  35     }
  36
  37     void TearDown()
  38     {
  39         //print_lmc_get_scene();
  40         t_ilm_layer* layers = NULL;
  41         t_ilm_int numLayer=0;
  42         EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers));
  43         for (t_ilm_int i=0; i<numLayer; i++)
  44         {
  45             EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i]));
  46         };
  47         free(layers);
  48
  49         t_ilm_surface* surfaces = NULL;
  50         t_ilm_int numSurfaces=0;
  51         EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&numSurfaces, &surfaces));
  52         for (t_ilm_int i=0; i<numSurfaces; i++)
  53         {
  54             EXPECT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surfaces[i]));
  55         };
  56
  57         EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges());
  58         EXPECT_EQ(ILM_SUCCESS, ilm_destroy());
  59     }
  60 };
  61
  62 TEST_F(IlmCommandTest, SetGetSurfaceDimension) {
  63     uint surface = 36;
  64
  65     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 10, 10, ILM_PIXELFORMAT_RGBA_8888, &surface));
  66
  67     t_ilm_uint dim[2] = {15, 25};
  68     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDimension(surface, dim));
  69     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
  70
  71     t_ilm_uint dimreturned[2];
  72     EXPECT_EQ(ILM_SUCCESS, ilm_surfaceGetDimension(surface, dimreturned));
  73     EXPECT_EQ(dim[0], dimreturned[0]);
  74     EXPECT_EQ(dim[1], dimreturned[1]);
  75
  76     // cleanup
  77     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
  78 }
  79
  80 TEST_F(IlmCommandTest, SetGetSurfaceDimension_InvalidInput) {
  81     uint surface = 0xdeadbeef;
  82     t_ilm_uint dim[2] = {15, 25};
  83
  84     ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetDimension(surface, dim));
  85     EXPECT_NE(ILM_SUCCESS, ilm_surfaceGetDimension(surface, dim));
  86 }
  87
  88 TEST_F(IlmCommandTest, SetGetLayerDimension) {
  89     uint layer = 4316;
  90
  91     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
  92
  93     t_ilm_uint dim[2] = {115, 125};
  94     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDimension(layer, dim));
  95     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
  96
  97     t_ilm_uint dimreturned[2];
  98     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetDimension(layer, dimreturned));
  99     EXPECT_EQ(dim[0], dimreturned[0]);
 100     EXPECT_EQ(dim[1], dimreturned[1]);
 101
 102     // cleanup
 103     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 104 }
 105
 106 TEST_F(IlmCommandTest, SetGetLayerDimension_InvalidInput) {
 107     uint layer = 0xdeadbeef;
 108     t_ilm_uint dim[2] = {115, 125};
 109
 110     ASSERT_NE(ILM_SUCCESS, ilm_layerSetDimension(layer, dim));
 111     ASSERT_NE(ILM_SUCCESS, ilm_layerGetDimension(layer, dim));
 112
 113     // cleanup
 114     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 115 }
 116
 117 TEST_F(IlmCommandTest, SetGetSurfacePosition) {
 118     uint surface = 37;
 119
 120     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 10, 10, ILM_PIXELFORMAT_RGBA_8888, &surface));
 121
 122     t_ilm_uint pos[2] = {15, 25};
 123     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetPosition(surface, pos));
 124     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 125
 126     t_ilm_uint posreturned[2];
 127     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPosition(surface, posreturned));
 128     EXPECT_EQ(pos[0], posreturned[0]);
 129     EXPECT_EQ(pos[1], posreturned[1]);
 130
 131     // cleanup
 132     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 133 }
 134
 135 TEST_F(IlmCommandTest, SetGetSurfacePosition_InvalidInput) {
 136     uint surface = 0xdeadbeef;
 137     t_ilm_uint pos[2] = {15, 25};
 138     ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetPosition(surface, pos));
 139     ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetPosition(surface, pos));
 140 }
 141
 142 TEST_F(IlmCommandTest, SetGetLayerPosition) {
 143     uint layer = 4316;
 144
 145     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 146
 147     t_ilm_uint pos[2] = {115, 125};
 148     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetPosition(layer, pos));
 149     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 150
 151     t_ilm_uint posreturned[2];
 152     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetPosition(layer, posreturned));
 153     ASSERT_EQ(pos[0], posreturned[0]);
 154     ASSERT_EQ(pos[1], posreturned[1]);
 155
 156     // cleanup
 157     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 158 }
 159
 160 TEST_F(IlmCommandTest, SetGetLayerPosition_InvalidInput) {
 161     uint layer = 0xdeadbeef;
 162     t_ilm_uint pos[2] = {15, 25};
 163     ASSERT_NE(ILM_SUCCESS, ilm_layerSetPosition(layer, pos));
 164     ASSERT_NE(ILM_SUCCESS, ilm_layerGetPosition(layer, pos));
 165 }
 166
 167 TEST_F(IlmCommandTest, SetGetSurfaceOrientation) {
 168     uint surface = 36;
 169     ilmOrientation returned;
 170     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 171
 172     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
 173     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 174     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 175     ASSERT_EQ(ILM_NINETY, returned);
 176
 177     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ONEHUNDREDEIGHTY));
 178     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 179     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 180     ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
 181
 182     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
 183     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 184     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 185     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
 186
 187     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ZERO));
 188     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 189     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 190     ASSERT_EQ(ILM_ZERO, returned);
 191
 192     // cleanup
 193     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 194 }
 195
 196 TEST_F(IlmCommandTest, SetGetLayerOrientation) {
 197     uint layer = 4316;
 198     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 199     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 200     ilmOrientation returned;
 201
 202     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
 203     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 204     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 205     ASSERT_EQ(ILM_NINETY, returned);
 206
 207     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ONEHUNDREDEIGHTY));
 208     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 209     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 210     ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
 211
 212     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
 213     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 214     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 215     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
 216
 217     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ZERO));
 218     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 219     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 220     ASSERT_EQ(ILM_ZERO, returned);
 221
 222     // cleanup
 223     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 224 }
 225
 226 TEST_F(IlmCommandTest, SetGetSurfaceOpacity) {
 227     uint surface1 = 36;
 228     uint surface2 = 44;
 229     t_ilm_float opacity;
 230
 231     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 232     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 233
 234     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface1, 0.88));
 235     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 236     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface1, &opacity));
 237     EXPECT_NEAR(0.88, opacity, 0.01);
 238
 239     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface2, 0.001));
 240     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 241     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface2, &opacity));
 242     EXPECT_NEAR(0.001, opacity, 0.01);
 243
 244     // cleanup
 245     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 246     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 247 }
 248
 249 TEST_F(IlmCommandTest, SetGetSurfaceOpacity_InvalidInput) {
 250     t_ilm_uint surface = 0xdeadbeef;
 251     t_ilm_float opacity;
 252
 253     ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.88));
 254     ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetOpacity(surface, &opacity));
 255 }
 256
 257 TEST_F(IlmCommandTest, SetGetLayerOpacity) {
 258     uint layer1 = 36;
 259     uint layer2 = 44;
 260     t_ilm_float opacity;
 261
 262     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 263     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 264
 265     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer1, 0.88));
 266     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 267     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer1, &opacity));
 268     EXPECT_NEAR(0.88, opacity, 0.01);
 269
 270     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer2, 0.001));
 271     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 272     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer2, &opacity));
 273     EXPECT_NEAR(0.001, opacity, 0.01);
 274
 275     // cleanup
 276     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 277     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 278 }
 279
 280 TEST_F(IlmCommandTest, SetGetLayerOpacity_InvalidInput) {
 281     t_ilm_layer layer = 0xdeadbeef;
 282     t_ilm_float opacity;
 283
 284     ASSERT_NE(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.88));
 285     ASSERT_NE(ILM_SUCCESS, ilm_layerGetOpacity(layer, &opacity));
 286 }
 287
 288 TEST_F(IlmCommandTest, SetGetSurfaceVisibility) {
 289     uint surface = 36;
 290     t_ilm_bool visibility;
 291
 292     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 293
 294     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
 295     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 296     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
 297     ASSERT_EQ(ILM_TRUE, visibility);
 298
 299     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_FALSE));
 300     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 301     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
 302     ASSERT_EQ(ILM_FALSE, visibility);
 303
 304     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
 305     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 306     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
 307     ASSERT_EQ(ILM_TRUE, visibility);
 308
 309     // cleanup
 310     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 311 }
 312
 313 TEST_F(IlmCommandTest, SetGetSurfaceVisibility_InvalidInput) {
 314     uint surface = 0xdeadbeef;
 315     t_ilm_bool visibility;
 316
 317     ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
 318     ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
 319     ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_FALSE));
 320 }
 321
 322 TEST_F(IlmCommandTest, SetGetLayerVisibility) {
 323     uint layer = 36;
 324     t_ilm_bool visibility;
 325
 326     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 327
 328     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
 329     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 330     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
 331     ASSERT_EQ(ILM_TRUE, visibility);
 332
 333     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_FALSE));
 334     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 335     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
 336     ASSERT_EQ(ILM_FALSE, visibility);
 337
 338     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
 339     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 340     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
 341     ASSERT_EQ(ILM_TRUE, visibility);
 342
 343     // cleanup
 344     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 345 }
 346
 347 TEST_F(IlmCommandTest, SetGetLayerVisibility_InvalidInput) {
 348     uint layer = 0xdeadbeef;
 349     t_ilm_bool visibility;
 350
 351     ASSERT_NE(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
 352     ASSERT_NE(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
 353     ASSERT_NE(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_FALSE));
 354 }
 355
 356 TEST_F(IlmCommandTest, SetSurfaceSourceRectangle) {
 357     t_ilm_uint surface = 0xbeef;
 358     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 359     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 360
 361     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
 362     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 363
 364     ilmSurfaceProperties surfaceProperties;
 365     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
 366     ASSERT_EQ(89u, surfaceProperties.sourceX);
 367     ASSERT_EQ(6538u, surfaceProperties.sourceY);
 368     ASSERT_EQ(638u, surfaceProperties.sourceWidth);
 369     ASSERT_EQ(4u, surfaceProperties.sourceHeight);
 370
 371     // cleaning
 372     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 373 }
 374
 375 TEST_F(IlmCommandTest, SetSurfaceSourceRectangle_InvalidInput) {
 376     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(0xdeadbeef, 89, 6538, 638, 4));
 377     ASSERT_NE(ILM_SUCCESS, ilm_commitChanges());
 378 }
 379
 380 TEST_F(IlmCommandTest, ilm_getScreenIDs) {
 381     t_ilm_uint numberOfScreens = 0;
 382     t_ilm_uint* screenIDs = NULL;
 383     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 384     ASSERT_GT(numberOfScreens, 0u);
 385 }
 386
 387 TEST_F(IlmCommandTest, ilm_getScreenResolution_SingleScreen) {
 388     t_ilm_uint numberOfScreens = 0;
 389     t_ilm_uint* screenIDs = NULL;
 390     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 391     ASSERT_TRUE(numberOfScreens>0);
 392
 393     uint firstScreen = screenIDs[0];
 394     t_ilm_uint width = 0, height = 0;
 395     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(firstScreen, &width, &height));
 396     ASSERT_GT(width, 0u);
 397     ASSERT_GT(height, 0u);
 398 }
 399
 400 TEST_F(IlmCommandTest, ilm_getScreenResolution_MultiScreen) {
 401     t_ilm_uint numberOfScreens = 0;
 402     t_ilm_uint* screenIDs = NULL;
 403     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 404     ASSERT_TRUE(numberOfScreens>0);
 405
 406     for (uint screenIndex = 0; screenIndex < numberOfScreens; ++screenIndex)
 407     {
 408         uint screen = screenIDs[screenIndex];
 409         t_ilm_uint width = 0, height = 0;
 410         ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(screen, &width, &height));
 411         ASSERT_GT(width, 0u);
 412         ASSERT_GT(height, 0u);
 413     }
 414 }
 415
 416 TEST_F(IlmCommandTest, ilm_getLayerIDs) {
 417     uint layer1 = 3246;
 418     uint layer2 = 46586;
 419
 420     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 421     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 422     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 423
 424     t_ilm_int length;
 425     t_ilm_uint* IDs;
 426     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 427
 428     ASSERT_EQ(layer1, IDs[0]);
 429     ASSERT_EQ(layer2, IDs[1]);
 430     free(IDs);
 431
 432     // cleanup
 433     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 434     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 435 }
 436
 437 TEST_F(IlmCommandTest, ilm_getLayerIDsOfScreen) {
 438     t_ilm_layer layer1 = 3246;
 439     t_ilm_layer layer2 = 46586;
 440     t_ilm_uint roLength = 2;
 441     t_ilm_layer idRenderOrder[2] = {layer1, layer2};
 442     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 443     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 444     ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(0, idRenderOrder, roLength));
 445     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 446
 447     t_ilm_int length = 0;
 448     t_ilm_layer* IDs = 0;
 449     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDsOnScreen(0, &length, &IDs));
 450
 451     ASSERT_EQ(2, length);
 452     EXPECT_EQ(layer1, IDs[0]);
 453     EXPECT_EQ(layer2, IDs[1]);
 454
 455     // cleanup
 456     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 457     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 458 }
 459
 460 TEST_F(IlmCommandTest, ilm_getSurfaceIDs) {
 461     uint surface1 = 3246;
 462     uint surface2 = 46586;
 463     t_ilm_uint* IDs;
 464     t_ilm_int old_length;
 465
 466     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&old_length, &IDs));
 467     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 468     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 469     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 470     free(IDs);
 471
 472     t_ilm_int length;
 473     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 474
 475     ASSERT_EQ(old_length+2, length);
 476     ASSERT_EQ(surface1, IDs[old_length]);
 477     ASSERT_EQ(surface2, IDs[old_length+1]);
 478     free(IDs);
 479
 480     // cleanup
 481     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 482     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 483 }
 484
 485 TEST_F(IlmCommandTest, ilm_surfaceCreate_Remove) {
 486     uint surface1 = 3246;
 487     uint surface2 = 46586;
 488     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 489     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 490     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 491
 492     t_ilm_int length;
 493     t_ilm_uint* IDs;
 494     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 495
 496     ASSERT_EQ(length, 2);
 497     ASSERT_EQ(surface1, IDs[0]);
 498     ASSERT_EQ(surface2, IDs[1]);
 499
 500     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 501     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 502     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 503     ASSERT_EQ(length, 1);
 504     ASSERT_EQ(surface2, IDs[0]);
 505
 506     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 507     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 508     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 509     ASSERT_EQ(length, 0);
 510 }
 511
 512 TEST_F(IlmCommandTest, ilm_layerCreate_Remove) {
 513     uint layer1 = 3246;
 514     uint layer2 = 46586;
 515     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 516     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 517     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 518
 519     t_ilm_int length;
 520     t_ilm_uint* IDs;
 521     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 522
 523     ASSERT_EQ(length, 2);
 524     ASSERT_EQ(layer1, IDs[0]);
 525     ASSERT_EQ(layer2, IDs[1]);
 526     free(IDs);
 527
 528     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 529     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 530     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 531     ASSERT_EQ(length, 1);
 532     ASSERT_EQ(layer2, IDs[0]);
 533     free(IDs);
 534
 535     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 536     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 537     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 538     ASSERT_EQ(length, 0);
 539     free(IDs);
 540 }
 541
 542 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidInput) {
 543     t_ilm_int length;
 544     t_ilm_uint* IDs;
 545     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 546     free(IDs);
 547
 548     t_ilm_int new_length;
 549     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(0xdeadbeef));
 550     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 551     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&new_length, &IDs));
 552     ASSERT_EQ(length, new_length);
 553     free(IDs);
 554 }
 555
 556 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidUse) {
 557     uint layer = 0xdeadbeef;
 558     t_ilm_uint* IDs;
 559     t_ilm_int orig_length;
 560     t_ilm_int length;
 561     t_ilm_int new_length;
 562
 563     // get the initial number of layers
 564     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&orig_length, &IDs));
 565     free(IDs);
 566
 567     // add the layer
 568     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 569     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 570     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 571     ASSERT_EQ(length, orig_length+1);
 572     free(IDs);
 573
 574     // remove the new layer
 575     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 576     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 577     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 578     ASSERT_EQ(length, orig_length);
 579     free(IDs);
 580
 581     // try to remove the same layer once more
 582     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 583     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 584     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&new_length, &IDs));
 585     ASSERT_EQ(length, new_length);
 586     free(IDs);
 587 }
 588
 589 TEST_F(IlmCommandTest, ilm_layerGetType) {
 590     t_ilm_uint layer = 0xbeef;
 591     ilmLayerType type;
 592
 593     // add a layer and check its type
 594     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 595     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 596     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(layer, &type));
 597     ASSERT_EQ(ILM_LAYERTYPE_SOFTWARE2D, type);
 598
 599     // cleanup
 600     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(0xbeef));
 601 }
 602
 603 TEST_F(IlmCommandTest, ilm_layerGetType_InvalidInput) {
 604     ilmLayerType type;
 605
 606     // check type of a non-existing layer
 607     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(0xdeadbeef, &type));
 608     ASSERT_EQ(ILM_LAYERTYPE_UNKNOWN, type);
 609 }
 610
 611 TEST_F(IlmCommandTest, ilm_layerGetCapabilities) {
 612     t_ilm_uint layer = 0xbeef;
 613     t_ilm_layercapabilities caps;
 614     // TODO: unsupported
 615     t_ilm_layercapabilities exp_caps = 0;
 616
 617     // add a layer and check its capabilities
 618     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 619     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 620     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetCapabilities(layer, &caps));
 621     ASSERT_EQ(exp_caps, caps);
 622
 623     // cleanup
 624     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(0xbeef));
 625 }
 626
 627 TEST_F(IlmCommandTest, ilm_layerTypeGetCapabilities) {
 628     t_ilm_layercapabilities caps;
 629     // TODO: unsupported
 630     t_ilm_layercapabilities exp_caps = 0;
 631
 632     // check ILM_LAYERTYPE_UNKNOWN
 633     exp_caps = 0;
 634     ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_UNKNOWN, &caps));
 635     ASSERT_EQ(exp_caps, caps);
 636
 637     // check ILM_LAYERTYPE_HARDWARE
 638     exp_caps = 0;
 639     ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_HARDWARE, &caps));
 640     ASSERT_EQ(exp_caps, caps);
 641
 642     // check ILM_LAYERTYPE_SOFTWARE2D
 643     exp_caps = 0;
 644     ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2D, &caps));
 645     ASSERT_EQ(exp_caps, caps);
 646
 647     // check ILM_LAYERTYPE_SOFTWARE2_5D
 648     exp_caps = 1;
 649     ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2_5D, &caps));
 650     ASSERT_EQ(exp_caps, caps);
 651 }
 652
 653 TEST_F(IlmCommandTest, ilm_surface_initialize) {
 654     uint surface_10 = 10;
 655     uint surface_20 = 20;
 656     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_10));
 657     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_20));
 658
 659     t_ilm_int length;
 660     t_ilm_uint* IDs;
 661     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 662
 663     ASSERT_EQ(length, 2);
 664     ASSERT_EQ(surface_10, IDs[0]);
 665     ASSERT_EQ(surface_20, IDs[1]);
 666 }
 667
 668 TEST_F(IlmCommandTest, ilm_layerAddSurface_ilm_layerRemoveSurface_ilm_getSurfaceIDsOnLayer) {
 669     uint layer = 3246;
 670     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 671     uint surface1 = 3246;
 672     uint surface2 = 46586;
 673     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 674     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 675     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 676
 677     t_ilm_int length;
 678     t_ilm_uint* IDs;
 679     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 680     ASSERT_EQ(length, 0);
 681     free(IDs);
 682
 683     ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface1));
 684     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 685     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 686     ASSERT_EQ(length, 1);
 687     ASSERT_EQ(surface1, IDs[0]);
 688     free(IDs);
 689
 690     ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface2));
 691     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 692     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 693     ASSERT_EQ(length, 2);
 694     ASSERT_EQ(surface1, IDs[0]);
 695     ASSERT_EQ(surface2, IDs[1]);
 696     free(IDs);
 697
 698     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface1));
 699     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 700     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 701     ASSERT_EQ(length, 1);
 702     ASSERT_EQ(surface2, IDs[0]);
 703     free(IDs);
 704
 705     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface2));
 706     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 707     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 708     ASSERT_EQ(length, 0);
 709     free(IDs);
 710
 711     // cleanup
 712     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 713     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 714     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 715 }
 716
 717 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidInput) {
 718     uint layer = 0xdeadbeef;
 719
 720     t_ilm_int length;
 721     t_ilm_uint* IDs;
 722     ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 723 }
 724
 725 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidResources) {
 726     uint layer = 3246;
 727     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 728     uint surface1 = 0xbeef1;
 729     uint surface2 = 0xbeef2;
 730     uint surface3 = 0xbeef3;
 731     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 732     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 733     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface3));
 734     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 735
 736     t_ilm_int length;
 737     t_ilm_uint IDs[3];
 738     IDs[0] = surface1;
 739     IDs[1] = surface2;
 740     IDs[2] = surface3;
 741     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, IDs, 3));
 742     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 743
 744     ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, NULL));
 745
 746     // cleanup
 747     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 748     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 749     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface3));
 750     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 751 }
 752
 753 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_ilm_surfaceSetSourceRectangle_ilm_surfaceSetDestinationRectangle) {
 754     t_ilm_uint surface = 0xbeef;
 755     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 756     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 757
 758     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.8765));
 759     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
 760     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 54, 47, 947, 9));
 761     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
 762     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, true));
 763     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 764
 765     ilmSurfaceProperties surfaceProperties;
 766     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
 767     ASSERT_NEAR(0.8765, surfaceProperties.opacity, 0.1);
 768     ASSERT_EQ(89u, surfaceProperties.sourceX);
 769     ASSERT_EQ(6538u, surfaceProperties.sourceY);
 770     ASSERT_EQ(638u, surfaceProperties.sourceWidth);
 771     ASSERT_EQ(4u, surfaceProperties.sourceHeight);
 772     ASSERT_EQ(54u, surfaceProperties.destX);
 773     ASSERT_EQ(47u, surfaceProperties.destY);
 774     ASSERT_EQ(947u, surfaceProperties.destWidth);
 775     ASSERT_EQ(9u, surfaceProperties.destHeight);
 776     ASSERT_EQ(ILM_NINETY, surfaceProperties.orientation);
 777     ASSERT_TRUE( surfaceProperties.visibility);
 778
 779     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.436));
 780     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 784, 546, 235, 78));
 781     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 536, 5372, 3, 4316));
 782     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
 783     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, false));
 784     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 785
 786     ilmSurfaceProperties surfaceProperties2;
 787     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties2));
 788     ASSERT_NEAR(0.436, surfaceProperties2.opacity, 0.1);
 789     ASSERT_EQ(784u, surfaceProperties2.sourceX);
 790     ASSERT_EQ(546u, surfaceProperties2.sourceY);
 791     ASSERT_EQ(235u, surfaceProperties2.sourceWidth);
 792     ASSERT_EQ(78u, surfaceProperties2.sourceHeight);
 793     ASSERT_EQ(536u, surfaceProperties2.destX);
 794     ASSERT_EQ(5372u, surfaceProperties2.destY);
 795     ASSERT_EQ(3u, surfaceProperties2.destWidth);
 796     ASSERT_EQ(4316u, surfaceProperties2.destHeight);
 797     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, surfaceProperties2.orientation);
 798     ASSERT_FALSE(surfaceProperties2.visibility);
 799
 800     // cleaning
 801     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 802 }
 803
 804 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_ilm_surfaceSetSourceRectangle_ilm_surfaceSetDestinationRectangle_ilm_surfaceSetChromaKey) {
 805     t_ilm_uint surface = 0xbeef;
 806     t_ilm_int chromaKey[3] = {3, 22, 111};
 807     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 808     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 809
 810     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.8765));
 811     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
 812     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 54, 47, 947, 9));
 813     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
 814     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, true));
 815     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetChromaKey(surface, &chromaKey[0]));
 816     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 817
 818     ilmSurfaceProperties surfaceProperties;
 819     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
 820     ASSERT_EQ(0.8765, surfaceProperties.opacity);
 821     ASSERT_EQ(89u, surfaceProperties.sourceX);
 822     ASSERT_EQ(6538u, surfaceProperties.sourceY);
 823     ASSERT_EQ(638u, surfaceProperties.sourceWidth);
 824     ASSERT_EQ(4u, surfaceProperties.sourceHeight);
 825     ASSERT_EQ(54u, surfaceProperties.destX);
 826     ASSERT_EQ(47u, surfaceProperties.destY);
 827     ASSERT_EQ(947u, surfaceProperties.destWidth);
 828     ASSERT_EQ(9u, surfaceProperties.destHeight);
 829     ASSERT_EQ(ILM_NINETY, surfaceProperties.orientation);
 830     ASSERT_TRUE( surfaceProperties.visibility);
 831     ASSERT_TRUE( surfaceProperties.chromaKeyEnabled);
 832     ASSERT_EQ(3u, surfaceProperties.chromaKeyRed);
 833     ASSERT_EQ(22u, surfaceProperties.chromaKeyGreen);
 834     ASSERT_EQ(111u, surfaceProperties.chromaKeyBlue);
 835
 836     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.436));
 837     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 784, 546, 235, 78));
 838     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 536, 5372, 3, 4316));
 839     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
 840     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, false));
 841     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetChromaKey(surface, NULL));
 842     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 843
 844     ilmSurfaceProperties surfaceProperties2;
 845     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties2));
 846     ASSERT_EQ(0.436, surfaceProperties2.opacity);
 847     ASSERT_EQ(784u, surfaceProperties2.sourceX);
 848     ASSERT_EQ(546u, surfaceProperties2.sourceY);
 849     ASSERT_EQ(235u, surfaceProperties2.sourceWidth);
 850     ASSERT_EQ(78u, surfaceProperties2.sourceHeight);
 851     ASSERT_EQ(536u, surfaceProperties2.destX);
 852     ASSERT_EQ(5372u, surfaceProperties2.destY);
 853     ASSERT_EQ(3u, surfaceProperties2.destWidth);
 854     ASSERT_EQ(4316u, surfaceProperties2.destHeight);
 855     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, surfaceProperties2.orientation);
 856     ASSERT_FALSE(surfaceProperties2.visibility);
 857     ASSERT_FALSE(surfaceProperties2.chromaKeyEnabled);
 858
 859     // cleaning
 860     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 861 }
 862
 863 TEST_F(IlmCommandTest, ilm_getPropertiesOfLayer_ilm_layerSetSourceRectangle_ilm_layerSetDestinationRectangle_ilm_layerSetChromaKey) {
 864     t_ilm_uint layer = 0xbeef;
 865     t_ilm_int chromaKey[3] = {3, 22, 111};
 866     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 867     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 868
 869     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.8765));
 870     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 89, 6538, 638, 4));
 871     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 54, 47, 947, 9));
 872     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
 873     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, true));
 874     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetChromaKey(layer, chromaKey));
 875     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 876
 877     ilmLayerProperties layerProperties1;
 878     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties1));
 879     ASSERT_EQ(0.8765, layerProperties1.opacity);
 880     ASSERT_EQ(89u, layerProperties1.sourceX);
 881     ASSERT_EQ(6538u, layerProperties1.sourceY);
 882     ASSERT_EQ(638u, layerProperties1.sourceWidth);
 883     ASSERT_EQ(4u, layerProperties1.sourceHeight);
 884     ASSERT_EQ(54u, layerProperties1.destX);
 885     ASSERT_EQ(47u, layerProperties1.destY);
 886     ASSERT_EQ(947u, layerProperties1.destWidth);
 887     ASSERT_EQ(9u, layerProperties1.destHeight);
 888     ASSERT_EQ(ILM_NINETY, layerProperties1.orientation);
 889     ASSERT_TRUE( layerProperties1.visibility);
 890     ASSERT_TRUE(layerProperties1.chromaKeyEnabled);
 891     ASSERT_EQ(3u,   layerProperties1.chromaKeyRed);
 892     ASSERT_EQ(22u,  layerProperties1.chromaKeyGreen);
 893     ASSERT_EQ(111u, layerProperties1.chromaKeyBlue);
 894
 895     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.436));
 896     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 784, 546, 235, 78));
 897     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 536, 5372, 3, 4316));
 898     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
 899     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, false));
 900     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetChromaKey(layer, NULL));
 901     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 902
 903     ilmLayerProperties layerProperties2;
 904     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties2));
 905     ASSERT_EQ(0.436, layerProperties2.opacity);
 906     ASSERT_EQ(784u, layerProperties2.sourceX);
 907     ASSERT_EQ(546u, layerProperties2.sourceY);
 908     ASSERT_EQ(235u, layerProperties2.sourceWidth);
 909     ASSERT_EQ(78u, layerProperties2.sourceHeight);
 910     ASSERT_EQ(536u, layerProperties2.destX);
 911     ASSERT_EQ(5372u, layerProperties2.destY);
 912     ASSERT_EQ(3u, layerProperties2.destWidth);
 913     ASSERT_EQ(4316u, layerProperties2.destHeight);
 914     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, layerProperties2.orientation);
 915     ASSERT_FALSE(layerProperties2.visibility);
 916     ASSERT_FALSE(layerProperties2.chromaKeyEnabled);
 917
 918     // cleanup
 919     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 920 }
 921
 922 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_InvalidInput) {
 923     ilmSurfaceProperties surfaceProperties;
 924     ASSERT_NE(ILM_SUCCESS, ilm_getPropertiesOfSurface(0xdeadbeef, &surfaceProperties));
 925 }
 926
 927 TEST_F(IlmCommandTest, ilm_takeScreenshot) {
 928     // make sure the file is not there before
 929     FILE* f = fopen("/tmp/test.bmp", "r");
 930     if (f!=NULL){
 931         fclose(f);
 932         int result = remove("/tmp/test.bmp");
 933         ASSERT_EQ(0, result);
 934     }
 935
 936     ASSERT_EQ(ILM_SUCCESS, ilm_takeScreenshot(0, "/tmp/test.bmp"));
 937
 938     sleep(1);
 939     f = fopen("/tmp/test.bmp", "r");
 940     ASSERT_TRUE(f!=NULL);
 941     fclose(f);
 942 }
 943
 944 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat) {
 945     t_ilm_uint surface1=0;
 946     t_ilm_uint surface2=1;
 947     t_ilm_uint surface3=2;
 948     t_ilm_uint surface4=3;
 949     t_ilm_uint surface5=4;
 950     t_ilm_uint surface6=5;
 951     t_ilm_uint surface7=6;
 952
 953     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_4444, &surface1));
 954     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_5551, &surface2));
 955     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_6661, &surface3));
 956     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface4));
 957     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGB_565, &surface5));
 958     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGB_888, &surface6));
 959     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_R_8, &surface7));
 960     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 961
 962     ilmPixelFormat p1, p2, p3, p4, p5, p6, p7;
 963
 964     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface1, &p1));
 965     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface2, &p2));
 966     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface3, &p3));
 967     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface4, &p4));
 968     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface5, &p5));
 969     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface6, &p6));
 970     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface7, &p7));
 971
 972     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_4444, p1);
 973     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_5551, p2);
 974     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_6661, p3);
 975     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_8888, p4);
 976     ASSERT_EQ(ILM_PIXELFORMAT_RGB_565, p5);
 977     ASSERT_EQ(ILM_PIXELFORMAT_RGB_888, p6);
 978     ASSERT_EQ(ILM_PIXELFORMAT_R_8, p7);
 979
 980     // cleanup
 981     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 982     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 983     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface3));
 984     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface4));
 985     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface5));
 986     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface6));
 987     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface7));
 988 }
 989
 990 TEST_F(IlmCommandTest, ilm_keyboard_focus)
 991 {
 992     uint surface;
 993     uint surface1 = 36;
 994     uint surface2 = 44;
 995
 996     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 997     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 998
 999     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
1000     EXPECT_EQ(0xFFFFFFFF, surface);
1001
1002     ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
1003     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
1004     EXPECT_EQ(surface1, surface);
1005
1006     // cleanup
1007     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
1008     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
1009 }
1010
1011 TEST_F(IlmCommandTest, ilm_input_event_acceptance) {
1012     uint surface;
1013     uint surface1 = 36;
1014     uint surface2 = 44;
1015     ilmSurfaceProperties surfaceProperties;
1016
1017     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
1018     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
1019
1020     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1021     EXPECT_EQ(ILM_INPUT_DEVICE_ALL, surfaceProperties.inputDevicesAcceptance);
1022
1023     ASSERT_EQ(ILM_SUCCESS, ilm_UpdateInputEventAcceptanceOn(surface1, (ilmInputDevice) (ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_POINTER), false));
1024     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1025
1026
1027     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1028     EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_KEYBOARD);
1029     EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_POINTER);
1030     EXPECT_TRUE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_TOUCH);
1031
1032     ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
1033     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
1034     EXPECT_NE(surface1, surface);
1035
1036     // cleanup
1037     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
1038     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
1039 }
1040
1041 TEST_F(IlmCommandTest, SetGetOptimizationMode) {
1042     ilmOptimization id;
1043     ilmOptimizationMode mode;
1044     ilmOptimizationMode retmode;
1045
1046     id = ILM_OPT_MULTITEXTURE;
1047     mode = ILM_OPT_MODE_FORCE_OFF;
1048     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1049     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1050     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1051     ASSERT_EQ(mode, retmode);
1052
1053     id = ILM_OPT_SKIP_CLEAR;
1054     mode = ILM_OPT_MODE_TOGGLE;
1055     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1056     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1057     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1058     ASSERT_EQ(mode, retmode);
1059
1060     id = ILM_OPT_MULTITEXTURE;
1061     mode = ILM_OPT_MODE_HEURISTIC;
1062     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1063     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1064     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1065     ASSERT_EQ(mode, retmode);
1066 }
1067
1068 TEST_F(IlmCommandTest, ilm_getPropertiesOfScreen) {
1069     t_ilm_uint numberOfScreens = 0;
1070     t_ilm_uint* screenIDs = NULL;
1071     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
1072     ASSERT_TRUE(numberOfScreens>0);
1073
1074     t_ilm_display screen = screenIDs[0];
1075     ilmScreenProperties screenProperties;
1076
1077     t_ilm_layer layerIds[3] = {100, 200, 300};//t_ilm_layer layerIds[3] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1078     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds, 800, 480));
1079     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 1, 800, 480));
1080     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 2, 800, 480));
1081
1082     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1083
1084     ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, layerIds, 3));
1085
1086     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1087
1088
1089     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProperties));
1090     ASSERT_EQ(3, screenProperties.layerCount);
1091     ASSERT_EQ(layerIds[0], screenProperties.layerIds[0]);
1092     ASSERT_EQ(layerIds[1], screenProperties.layerIds[1]);
1093     ASSERT_EQ(layerIds[2], screenProperties.layerIds[2]);
1094
1095     ASSERT_GT(screenProperties.screenWidth, 0u);
1096     ASSERT_GT(screenProperties.screenHeight, 0u);
1097
1098     t_ilm_uint numberOfHardwareLayers;
1099     ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
1100     ASSERT_EQ(numberOfHardwareLayers, screenProperties.harwareLayerCount);
1101
1102     // cleanup
1103     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[0]));
1104     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[1]));
1105     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[2]));
1106 }
1107
1108 TEST_F(IlmCommandTest, DisplaySetRenderOrder_growing) {
1109     //prepare needed layers
1110     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1111     t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1112
1113     for (unsigned int i = 0; i < layerCount; ++i)
1114     {
1115         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1116         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1117     }
1118
1119     t_ilm_display* screenIDs;
1120     t_ilm_uint screenCount;
1121     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1122
1123     for(unsigned int i = 0; i < screenCount; ++i)
1124     {
1125         t_ilm_display screen = screenIDs[i];
1126         ilmScreenProperties screenProps;
1127
1128         //trying different render orders with increasing sizes
1129         for (unsigned int j = layerCount; j <= layerCount; --j) // note: using overflow here
1130         {
1131             //put them from end to beginning, so that in each loop iteration the order of layers change
1132             ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1133             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1134             ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1135
1136             ASSERT_EQ(layerCount - j, screenProps.layerCount);
1137             for(unsigned int k = 0; k < layerCount - j; ++k)
1138             {
1139                 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1140             }
1141         }
1142     }
1143
1144     // cleanup
1145     for (unsigned int i = 0; i < layerCount; ++i)
1146     {
1147         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(renderOrder[i]));
1148     }
1149 }
1150
1151 TEST_F(IlmCommandTest, DisplaySetRenderOrder_shrinking) {
1152     //prepare needed layers
1153     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1154     t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1155
1156     for (unsigned int i = 0; i < layerCount; ++i)
1157     {
1158         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1159         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1160     }
1161
1162     t_ilm_display* screenIDs;
1163     t_ilm_uint screenCount;
1164     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1165
1166     for(unsigned int i = 0; i < screenCount; ++i)
1167     {
1168         t_ilm_display screen = screenIDs[i];
1169         ilmScreenProperties screenProps;
1170
1171         //trying different render orders with decreasing sizes
1172         for (unsigned int j = 0; j <= layerCount; ++j)
1173         {
1174             //put them from end to beginning, so that in each loop iteration the order of layers change
1175             ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1176             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1177             ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1178
1179             ASSERT_EQ(layerCount - j, screenProps.layerCount);
1180             for(unsigned int k = 0; k < layerCount - j; ++k)
1181             {
1182                 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1183             }
1184         }
1185     }
1186
1187     // cleanup
1188     for (unsigned int i = 0; i < layerCount; ++i)
1189     {
1190         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(renderOrder[i]));
1191     }
1192 }
1193
1194 TEST_F(IlmCommandTest, LayerSetRenderOrder_growing) {
1195     //prepare needed layers and surfaces
1196     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1197     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1198
1199     for (unsigned int i = 0; i < surfaceCount; ++i)
1200     {
1201         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1202         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1203     }
1204
1205     t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1206     t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1207
1208     for (unsigned int i = 0; i < layerCount; ++i)
1209     {
1210         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1211         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1212     }
1213
1214     t_ilm_display* screenIDs;
1215     t_ilm_uint screenCount;
1216     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1217
1218     for(unsigned int i = 0; i < layerCount; ++i)
1219     {
1220         t_ilm_layer layer = layerIDs[i];
1221
1222         t_ilm_int layerSurfaceCount;
1223         t_ilm_surface* layerSurfaceIDs;
1224
1225         //trying different render orders with increasing sizes
1226         for (unsigned int j = surfaceCount; j <= surfaceCount; --j) // note: using overflow here
1227         {
1228             //put them from end to beginning, so that in each loop iteration the order of surafces change
1229             ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1230             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1231             ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1232
1233             ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1234             for(unsigned int k = 0; k < surfaceCount - j; ++k)
1235             {
1236                 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1237             }
1238         }
1239
1240         //set empty render order again
1241         ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1242         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1243     }
1244
1245     // cleanup
1246     for (unsigned int i = 0; i < surfaceCount; ++i)
1247     {
1248         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1249     }
1250     for (unsigned int i = 0; i < layerCount; ++i)
1251     {
1252         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIDs[i]));
1253     }
1254 }
1255
1256 TEST_F(IlmCommandTest, LayerSetRenderOrder_shrinking) {
1257     //prepare needed layers and surfaces
1258     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1259     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1260
1261     for (unsigned int i = 0; i < surfaceCount; ++i)
1262     {
1263         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1264         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1265     }
1266
1267     t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1268     t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1269
1270     for (unsigned int i = 0; i < layerCount; ++i)
1271     {
1272         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1273         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1274     }
1275
1276     t_ilm_display* screenIDs;
1277     t_ilm_uint screenCount;
1278     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1279
1280     for(unsigned int i = 0; i < layerCount; ++i)
1281     {
1282         t_ilm_layer layer = layerIDs[i];
1283
1284         t_ilm_int layerSurfaceCount;
1285         t_ilm_surface* layerSurfaceIDs;
1286
1287         //trying different render orders with decreasing sizes
1288         for (unsigned int j = 0; j <= layerCount; ++j)
1289         {
1290             //put them from end to beginning, so that in each loop iteration the order of surafces change
1291             ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1292             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1293             ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1294
1295             ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1296             for(unsigned int k = 0; k < surfaceCount - j; ++k)
1297             {
1298                 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1299             }
1300         }
1301
1302         //set empty render order again
1303         ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1304         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1305     }
1306
1307     // cleanup
1308     for (unsigned int i = 0; i < surfaceCount; ++i)
1309     {
1310         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1311     }
1312     for (unsigned int i = 0; i < layerCount; ++i)
1313     {
1314         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIDs[i]));
1315     }
1316 }
1317
1318 TEST_F(IlmCommandTest, LayerSetRenderOrder_duplicates) {
1319     //prepare needed layers and surfaces
1320     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1321     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1322
1323     for (unsigned int i = 0; i < surfaceCount; ++i)
1324     {
1325         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1326         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1327     }
1328
1329     t_ilm_surface duplicateRenderOrder[] = {renderOrder[0], renderOrder[1], renderOrder[0], renderOrder[1], renderOrder[0]};
1330     t_ilm_int duplicateSurfaceCount = sizeof(duplicateRenderOrder) / sizeof(duplicateRenderOrder[0]);
1331
1332     t_ilm_layer layer;
1333     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1334     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1335
1336     t_ilm_display* screenIDs;
1337     t_ilm_uint screenCount;
1338     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1339
1340     t_ilm_int layerSurfaceCount;
1341     t_ilm_surface* layerSurfaceIDs;
1342
1343     //trying duplicates
1344     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, duplicateRenderOrder, duplicateSurfaceCount));
1345     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1346     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1347
1348     ASSERT_EQ(2, layerSurfaceCount);
1349
1350     // cleanup
1351     for (unsigned int i = 0; i < surfaceCount; ++i)
1352     {
1353         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1354     }
1355     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
1356 }
1357
1358 TEST_F(IlmCommandTest, LayerSetRenderOrder_empty) {
1359     //prepare needed layers and surfaces
1360     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1361     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1362
1363     for (unsigned int i = 0; i < surfaceCount; ++i)
1364     {
1365         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1366         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1367     }
1368
1369     t_ilm_layer layer;
1370     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1371     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1372
1373
1374     t_ilm_display* screenIDs;
1375     t_ilm_uint screenCount;
1376     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1377
1378     t_ilm_int layerSurfaceCount;
1379     t_ilm_surface* layerSurfaceIDs;
1380
1381     //test start
1382     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, surfaceCount));
1383     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1384
1385     //set empty render order
1386     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1387     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1388     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1389
1390     ASSERT_EQ(0, layerSurfaceCount);
1391
1392     // cleanup
1393     for (unsigned int i = 0; i < surfaceCount; ++i)
1394     {
1395         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1396     }
1397     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
1398 }