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