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