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