ivi-layermanagement-api/test/ilm_control_test.cpp

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