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