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, SetGetLayerDimension) {
  81     uint layer = 4316;
  82
  83     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
  84
  85     t_ilm_uint dim[2] = {115, 125};
  86     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDimension(layer, dim));
  87     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
  88
  89     t_ilm_uint dimreturned[2];
  90     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetDimension(layer, dimreturned));
  91     EXPECT_EQ(dim[0], dimreturned[0]);
  92     EXPECT_EQ(dim[1], dimreturned[1]);
  93
  94     // cleanup
  95     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
  96 }
  97
  98 TEST_F(IlmCommandTest, SetGetSurfacePosition) {
  99     uint surface = 37;
 100
 101     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 10, 10, ILM_PIXELFORMAT_RGBA_8888, &surface));
 102
 103     t_ilm_uint pos[2] = {15, 25};
 104     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetPosition(surface, pos));
 105     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 106
 107     t_ilm_uint posreturned[2];
 108     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPosition(surface, posreturned));
 109     EXPECT_EQ(pos[0], posreturned[0]);
 110     EXPECT_EQ(pos[1], posreturned[1]);
 111
 112     // cleanup
 113     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 114 }
 115
 116 TEST_F(IlmCommandTest, SetGetLayerPosition) {
 117     uint layer = 4316;
 118
 119     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 120
 121     t_ilm_uint pos[2] = {115, 125};
 122     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetPosition(layer, pos));
 123     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 124
 125     t_ilm_uint posreturned[2];
 126     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetPosition(layer, posreturned));
 127     ASSERT_EQ(pos[0], posreturned[0]);
 128     ASSERT_EQ(pos[1], posreturned[1]);
 129
 130     // cleanup
 131     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 132 }
 133
 134 TEST_F(IlmCommandTest, SetGetSurfaceOrientation) {
 135     uint surface = 36;
 136     ilmOrientation returned;
 137     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 138
 139     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
 140     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 141     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 142     ASSERT_EQ(ILM_NINETY, returned);
 143
 144     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ONEHUNDREDEIGHTY));
 145     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 146     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 147     ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
 148
 149     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
 150     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 151     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 152     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
 153
 154     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ZERO));
 155     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 156     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
 157     ASSERT_EQ(ILM_ZERO, returned);
 158
 159     // cleanup
 160     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 161 }
 162
 163 TEST_F(IlmCommandTest, SetGetLayerOrientation) {
 164     uint layer = 4316;
 165     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 166     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 167     ilmOrientation returned;
 168
 169     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
 170     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 171     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 172     ASSERT_EQ(ILM_NINETY, returned);
 173
 174     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ONEHUNDREDEIGHTY));
 175     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 176     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 177     ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
 178
 179     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
 180     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 181     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 182     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
 183
 184     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ZERO));
 185     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 186     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
 187     ASSERT_EQ(ILM_ZERO, returned);
 188
 189     // cleanup
 190     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 191 }
 192
 193 TEST_F(IlmCommandTest, SetGetSurfaceOpacity) {
 194     uint surface1 = 36;
 195     uint surface2 = 44;
 196     t_ilm_float opacity;
 197
 198     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 199     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 200
 201     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface1, 0.88));
 202     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 203     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface1, &opacity));
 204     EXPECT_FLOAT_EQ(0.88, opacity);
 205
 206     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface2, 0.001));
 207     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 208     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface2, &opacity));
 209     EXPECT_FLOAT_EQ(0.001, opacity);
 210
 211     // cleanup
 212     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 213     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 214 }
 215
 216 TEST_F(IlmCommandTest, SetGetLayerOpacity) {
 217     uint layer1 = 36;
 218     uint layer2 = 44;
 219     t_ilm_float opacity;
 220
 221     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 222     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 223
 224     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer1, 0.88));
 225     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 226     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer1, &opacity));
 227     EXPECT_FLOAT_EQ(0.88, opacity);
 228
 229     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer2, 0.001));
 230     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 231     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer2, &opacity));
 232     EXPECT_FLOAT_EQ(0.001, opacity);
 233
 234     // cleanup
 235     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 236     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 237 }
 238
 239 TEST_F(IlmCommandTest, SetGetSurfaceVisibility) {
 240     uint surface1 = 36;
 241     t_ilm_bool visibility;
 242
 243     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 244
 245     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface1, ILM_TRUE));
 246     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 247     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface1, &visibility));
 248     ASSERT_EQ(ILM_TRUE, visibility);
 249
 250     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface1, ILM_FALSE));
 251     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 252     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface1, &visibility));
 253     ASSERT_EQ(ILM_FALSE, visibility);
 254
 255     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface1, ILM_TRUE));
 256     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 257     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface1, &visibility));
 258     ASSERT_EQ(ILM_TRUE, visibility);
 259 }
 260
 261 TEST_F(IlmCommandTest, SetGetLayerVisibility) {
 262     uint layer1 = 36;
 263     t_ilm_bool visibility;
 264
 265     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 266
 267     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer1, ILM_TRUE));
 268     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 269     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer1, &visibility));
 270     ASSERT_EQ(ILM_TRUE, visibility);
 271
 272     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer1, ILM_FALSE));
 273     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 274     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer1, &visibility));
 275     ASSERT_EQ(ILM_FALSE, visibility);
 276
 277     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer1, ILM_TRUE));
 278     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 279     ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer1, &visibility));
 280     ASSERT_EQ(ILM_TRUE, visibility);
 281 }
 282
 283 TEST_F(IlmCommandTest, ilm_getScreenIDs) {
 284     t_ilm_uint numberOfScreens = 0;
 285     t_ilm_uint* screenIDs = NULL;
 286     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 287     ASSERT_GT(numberOfScreens, 0u);
 288 }
 289
 290 TEST_F(IlmCommandTest, ilm_getScreenResolution_SingleScreen) {
 291     t_ilm_uint numberOfScreens = 0;
 292     t_ilm_uint* screenIDs = NULL;
 293     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 294     ASSERT_TRUE(numberOfScreens>0);
 295
 296     uint firstScreen = screenIDs[0];
 297     t_ilm_uint width = 0, height = 0;
 298     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(firstScreen, &width, &height));
 299     ASSERT_GT(width, 0u);
 300     ASSERT_GT(height, 0u);
 301 }
 302
 303 TEST_F(IlmCommandTest, ilm_getScreenResolution_MultiScreen) {
 304     t_ilm_uint numberOfScreens = 0;
 305     t_ilm_uint* screenIDs = NULL;
 306     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 307     ASSERT_TRUE(numberOfScreens>0);
 308
 309     for (uint screenIndex = 0; screenIndex < numberOfScreens; ++screenIndex)
 310     {
 311         uint screen = screenIDs[screenIndex];
 312         t_ilm_uint width = 0, height = 0;
 313         ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(screen, &width, &height));
 314         ASSERT_GT(width, 0u);
 315         ASSERT_GT(height, 0u);
 316     }
 317 }
 318
 319 TEST_F(IlmCommandTest, ilm_getLayerIDs) {
 320     uint layer1 = 3246;
 321     uint layer2 = 46586;
 322
 323     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 324     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 325     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 326
 327     t_ilm_int length;
 328     t_ilm_uint* IDs;
 329     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 330
 331     ASSERT_EQ(layer1, IDs[0]);
 332     ASSERT_EQ(layer2, IDs[1]);
 333     free(IDs);
 334
 335     // cleanup
 336     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 337     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 338 }
 339
 340 TEST_F(IlmCommandTest, ilm_getLayerIDsOfScreen) {
 341     t_ilm_layer layer1 = 3246;
 342     t_ilm_layer layer2 = 46586;
 343     t_ilm_uint roLength = 2;
 344     t_ilm_layer idRenderOrder[2] = {layer1, layer2};
 345     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 346     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 347     ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(0, idRenderOrder, roLength));
 348     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 349
 350     t_ilm_int length = 0;
 351     t_ilm_layer* IDs = 0;
 352     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDsOnScreen(0, &length, &IDs));
 353
 354     ASSERT_EQ(2, length);
 355     EXPECT_EQ(layer1, IDs[0]);
 356     EXPECT_EQ(layer2, IDs[1]);
 357
 358     // cleanup
 359     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 360     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 361 }
 362
 363 TEST_F(IlmCommandTest, ilm_getSurfaceIDs) {
 364     uint surface1 = 3246;
 365     uint surface2 = 46586;
 366     t_ilm_uint* IDs;
 367     t_ilm_int old_length;
 368
 369     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&old_length, &IDs));
 370     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 371     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 372     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 373     free(IDs);
 374
 375     t_ilm_int length;
 376     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 377
 378     ASSERT_EQ(old_length+2, length);
 379     ASSERT_EQ(surface1, IDs[old_length]);
 380     ASSERT_EQ(surface2, IDs[old_length+1]);
 381     free(IDs);
 382
 383     // cleanup
 384     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 385     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 386 }
 387
 388 TEST_F(IlmCommandTest, ilm_surfaceCreate_Remove) {
 389     uint surface1 = 3246;
 390     uint surface2 = 46586;
 391     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 392     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 393     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 394
 395     t_ilm_int length;
 396     t_ilm_uint* IDs;
 397     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 398
 399     ASSERT_EQ(length, 2);
 400     ASSERT_EQ(surface1, IDs[0]);
 401     ASSERT_EQ(surface2, IDs[1]);
 402
 403     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 404     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 405     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 406     ASSERT_EQ(length, 1);
 407     ASSERT_EQ(surface2, IDs[0]);
 408
 409     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 410     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 411     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 412     ASSERT_EQ(length, 0);
 413 }
 414
 415 TEST_F(IlmCommandTest, ilm_layerCreate_Remove) {
 416     uint layer1 = 3246;
 417     uint layer2 = 46586;
 418     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
 419     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
 420     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 421
 422     t_ilm_int length;
 423     t_ilm_uint* IDs;
 424     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 425
 426     ASSERT_EQ(length, 2);
 427     ASSERT_EQ(layer1, IDs[0]);
 428     ASSERT_EQ(layer2, IDs[1]);
 429     free(IDs);
 430
 431     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
 432     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 433     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 434     ASSERT_EQ(length, 1);
 435     ASSERT_EQ(layer2, IDs[0]);
 436     free(IDs);
 437
 438     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
 439     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 440     ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
 441     ASSERT_EQ(length, 0);
 442     free(IDs);
 443 }
 444
 445 TEST_F(IlmCommandTest, ilm_surface_initialize) {
 446     uint surface_10 = 10;
 447     uint surface_20 = 20;
 448     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_10));
 449     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_20));
 450
 451     t_ilm_int length;
 452     t_ilm_uint* IDs;
 453     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
 454
 455     ASSERT_EQ(length, 2);
 456     ASSERT_EQ(surface_10, IDs[0]);
 457     ASSERT_EQ(surface_20, IDs[1]);
 458 }
 459
 460 TEST_F(IlmCommandTest, ilm_layerAddSurface_ilm_layerRemoveSurface_ilm_getSurfaceIDsOnLayer) {
 461     uint layer = 3246;
 462     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 463     uint surface1 = 3246;
 464     uint surface2 = 46586;
 465     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 466     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 467     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 468
 469     t_ilm_int length;
 470     t_ilm_uint* IDs;
 471     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 472     ASSERT_EQ(length, 0);
 473     free(IDs);
 474
 475     ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface1));
 476     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 477     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 478     ASSERT_EQ(length, 1);
 479     ASSERT_EQ(surface1, IDs[0]);
 480     free(IDs);
 481
 482     ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface2));
 483     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 484     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 485     ASSERT_EQ(length, 2);
 486     ASSERT_EQ(surface1, IDs[0]);
 487     ASSERT_EQ(surface2, IDs[1]);
 488     free(IDs);
 489
 490     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface1));
 491     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 492     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 493     ASSERT_EQ(length, 1);
 494     ASSERT_EQ(surface2, IDs[0]);
 495     free(IDs);
 496
 497     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface2));
 498     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 499     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
 500     ASSERT_EQ(length, 0);
 501     free(IDs);
 502
 503     // cleanup
 504     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 505     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 506     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 507 }
 508
 509 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_ilm_surfaceSetSourceRectangle_ilm_surfaceSetDestinationRectangle_ilm_surfaceSetChromaKey) {
 510     t_ilm_uint surface = 0xbeef;
 511     t_ilm_int chromaKey[3] = {3, 22, 111};
 512     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
 513     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 514
 515     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.8765));
 516     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
 517     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 54, 47, 947, 9));
 518     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
 519     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, true));
 520     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetChromaKey(surface, &chromaKey[0]));
 521     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 522
 523     ilmSurfaceProperties surfaceProperties;
 524     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
 525     ASSERT_EQ(0.8765, surfaceProperties.opacity);
 526     ASSERT_EQ(89u, surfaceProperties.sourceX);
 527     ASSERT_EQ(6538u, surfaceProperties.sourceY);
 528     ASSERT_EQ(638u, surfaceProperties.sourceWidth);
 529     ASSERT_EQ(4u, surfaceProperties.sourceHeight);
 530     ASSERT_EQ(54u, surfaceProperties.destX);
 531     ASSERT_EQ(47u, surfaceProperties.destY);
 532     ASSERT_EQ(947u, surfaceProperties.destWidth);
 533     ASSERT_EQ(9u, surfaceProperties.destHeight);
 534     ASSERT_EQ(ILM_NINETY, surfaceProperties.orientation);
 535     ASSERT_TRUE( surfaceProperties.visibility);
 536     ASSERT_TRUE( surfaceProperties.chromaKeyEnabled);
 537     ASSERT_EQ(3u, surfaceProperties.chromaKeyRed);
 538     ASSERT_EQ(22u, surfaceProperties.chromaKeyGreen);
 539     ASSERT_EQ(111u, surfaceProperties.chromaKeyBlue);
 540
 541     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.436));
 542     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 784, 546, 235, 78));
 543     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 536, 5372, 3, 4316));
 544     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
 545     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, false));
 546     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetChromaKey(surface, NULL));
 547     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 548
 549     ilmSurfaceProperties surfaceProperties2;
 550     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties2));
 551     ASSERT_EQ(0.436, surfaceProperties2.opacity);
 552     ASSERT_EQ(784u, surfaceProperties2.sourceX);
 553     ASSERT_EQ(546u, surfaceProperties2.sourceY);
 554     ASSERT_EQ(235u, surfaceProperties2.sourceWidth);
 555     ASSERT_EQ(78u, surfaceProperties2.sourceHeight);
 556     ASSERT_EQ(536u, surfaceProperties2.destX);
 557     ASSERT_EQ(5372u, surfaceProperties2.destY);
 558     ASSERT_EQ(3u, surfaceProperties2.destWidth);
 559     ASSERT_EQ(4316u, surfaceProperties2.destHeight);
 560     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, surfaceProperties2.orientation);
 561     ASSERT_FALSE(surfaceProperties2.visibility);
 562     ASSERT_FALSE(surfaceProperties2.chromaKeyEnabled);
 563
 564     // cleaning
 565     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
 566 }
 567
 568 TEST_F(IlmCommandTest, ilm_getPropertiesOfLayer_ilm_layerSetSourceRectangle_ilm_layerSetDestinationRectangle_ilm_layerSetChromaKey) {
 569     t_ilm_uint layer = 0xbeef;
 570     t_ilm_int chromaKey[3] = {3, 22, 111};
 571     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
 572     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 573
 574     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.8765));
 575     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 89, 6538, 638, 4));
 576     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 54, 47, 947, 9));
 577     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
 578     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, true));
 579     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetChromaKey(layer, chromaKey));
 580     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 581
 582     ilmLayerProperties layerProperties1;
 583     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties1));
 584     ASSERT_EQ(0.8765, layerProperties1.opacity);
 585     ASSERT_EQ(89u, layerProperties1.sourceX);
 586     ASSERT_EQ(6538u, layerProperties1.sourceY);
 587     ASSERT_EQ(638u, layerProperties1.sourceWidth);
 588     ASSERT_EQ(4u, layerProperties1.sourceHeight);
 589     ASSERT_EQ(54u, layerProperties1.destX);
 590     ASSERT_EQ(47u, layerProperties1.destY);
 591     ASSERT_EQ(947u, layerProperties1.destWidth);
 592     ASSERT_EQ(9u, layerProperties1.destHeight);
 593     ASSERT_EQ(ILM_NINETY, layerProperties1.orientation);
 594     ASSERT_TRUE( layerProperties1.visibility);
 595     ASSERT_TRUE(layerProperties1.chromaKeyEnabled);
 596     ASSERT_EQ(3u,   layerProperties1.chromaKeyRed);
 597     ASSERT_EQ(22u,  layerProperties1.chromaKeyGreen);
 598     ASSERT_EQ(111u, layerProperties1.chromaKeyBlue);
 599
 600     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.436));
 601     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 784, 546, 235, 78));
 602     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 536, 5372, 3, 4316));
 603     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
 604     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, false));
 605     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetChromaKey(layer, NULL));
 606     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 607
 608     ilmLayerProperties layerProperties2;
 609     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties2));
 610     ASSERT_EQ(0.436, layerProperties2.opacity);
 611     ASSERT_EQ(784u, layerProperties2.sourceX);
 612     ASSERT_EQ(546u, layerProperties2.sourceY);
 613     ASSERT_EQ(235u, layerProperties2.sourceWidth);
 614     ASSERT_EQ(78u, layerProperties2.sourceHeight);
 615     ASSERT_EQ(536u, layerProperties2.destX);
 616     ASSERT_EQ(5372u, layerProperties2.destY);
 617     ASSERT_EQ(3u, layerProperties2.destWidth);
 618     ASSERT_EQ(4316u, layerProperties2.destHeight);
 619     ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, layerProperties2.orientation);
 620     ASSERT_FALSE(layerProperties2.visibility);
 621     ASSERT_FALSE(layerProperties2.chromaKeyEnabled);
 622
 623     // cleanup
 624     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
 625 }
 626
 627 TEST_F(IlmCommandTest, ilm_takeScreenshot) {
 628     // make sure the file is not there before
 629     FILE* f = fopen("/tmp/test.bmp", "r");
 630     if (f!=NULL){
 631         fclose(f);
 632         int result = remove("/tmp/test.bmp");
 633         ASSERT_EQ(0, result);
 634     }
 635
 636     ASSERT_EQ(ILM_SUCCESS, ilm_takeScreenshot(0, "/tmp/test.bmp"));
 637
 638     sleep(1);
 639     f = fopen("/tmp/test.bmp", "r");
 640     ASSERT_TRUE(f!=NULL);
 641     fclose(f);
 642 }
 643
 644 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat) {
 645     t_ilm_uint surface1=0;
 646     t_ilm_uint surface2=1;
 647     t_ilm_uint surface3=2;
 648     t_ilm_uint surface4=3;
 649     t_ilm_uint surface5=4;
 650     t_ilm_uint surface6=5;
 651     t_ilm_uint surface7=6;
 652
 653     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_4444, &surface1));
 654     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_5551, &surface2));
 655     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_6661, &surface3));
 656     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface4));
 657     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGB_565, &surface5));
 658     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGB_888, &surface6));
 659     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_R_8, &surface7));
 660     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 661
 662     ilmPixelFormat p1, p2, p3, p4, p5, p6, p7;
 663
 664     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface1, &p1));
 665     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface2, &p2));
 666     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface3, &p3));
 667     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface4, &p4));
 668     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface5, &p5));
 669     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface6, &p6));
 670     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface7, &p7));
 671
 672     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_4444, p1);
 673     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_5551, p2);
 674     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_6661, p3);
 675     ASSERT_EQ(ILM_PIXELFORMAT_RGBA_8888, p4);
 676     ASSERT_EQ(ILM_PIXELFORMAT_RGB_565, p5);
 677     ASSERT_EQ(ILM_PIXELFORMAT_RGB_888, p6);
 678     ASSERT_EQ(ILM_PIXELFORMAT_R_8, p7);
 679
 680     // cleanup
 681     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 682     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 683     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface3));
 684     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface4));
 685     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface5));
 686     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface6));
 687     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface7));
 688 }
 689
 690 TEST_F(IlmCommandTest, ilm_keyboard_focus)
 691 {
 692     uint surface;
 693     uint surface1 = 36;
 694     uint surface2 = 44;
 695
 696     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 697     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 698
 699     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
 700     EXPECT_EQ(0xFFFFFFFF, surface);
 701
 702     ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
 703     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
 704     EXPECT_EQ(surface1, surface);
 705
 706     // cleanup
 707     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 708     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 709 }
 710
 711 TEST_F(IlmCommandTest, ilm_input_event_acceptance) {
 712     uint surface;
 713     uint surface1 = 36;
 714     uint surface2 = 44;
 715     ilmSurfaceProperties surfaceProperties;
 716
 717     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
 718     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
 719
 720     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
 721     EXPECT_EQ(ILM_INPUT_DEVICE_ALL, surfaceProperties.inputDevicesAcceptance);
 722
 723     ASSERT_EQ(ILM_SUCCESS, ilm_UpdateInputEventAcceptanceOn(surface1, (ilmInputDevice) (ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_POINTER), false));
 724     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 725
 726
 727     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
 728     EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_KEYBOARD);
 729     EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_POINTER);
 730     EXPECT_TRUE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_TOUCH);
 731
 732     ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
 733     ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
 734     EXPECT_NE(surface1, surface);
 735
 736     // cleanup
 737     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
 738     ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
 739 }
 740
 741 TEST_F(IlmCommandTest, SetGetOptimizationMode) {
 742     ilmOptimization id;
 743     ilmOptimizationMode mode;
 744     ilmOptimizationMode retmode;
 745
 746     id = ILM_OPT_MULTITEXTURE;
 747     mode = ILM_OPT_MODE_FORCE_OFF;
 748     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
 749     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 750     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
 751     ASSERT_EQ(mode, retmode);
 752
 753     id = ILM_OPT_SKIP_CLEAR;
 754     mode = ILM_OPT_MODE_TOGGLE;
 755     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
 756     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 757     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
 758     ASSERT_EQ(mode, retmode);
 759
 760     id = ILM_OPT_MULTITEXTURE;
 761     mode = ILM_OPT_MODE_HEURISTIC;
 762     ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
 763     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 764     ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
 765     ASSERT_EQ(mode, retmode);
 766 }
 767
 768 TEST_F(IlmCommandTest, ilm_getPropertiesOfScreen) {
 769     t_ilm_uint numberOfScreens = 0;
 770     t_ilm_uint* screenIDs = NULL;
 771     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
 772     ASSERT_TRUE(numberOfScreens>0);
 773
 774     t_ilm_display screen = screenIDs[0];
 775     ilmScreenProperties screenProperties;
 776
 777     t_ilm_layer layerIds[3] = {100, 200, 300};//t_ilm_layer layerIds[3] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 778     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds, 800, 480));
 779     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 1, 800, 480));
 780     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 2, 800, 480));
 781
 782     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 783
 784     ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, layerIds, 3));
 785
 786     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 787
 788
 789     ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProperties));
 790     ASSERT_EQ(3, screenProperties.layerCount);
 791     ASSERT_EQ(layerIds[0], screenProperties.layerIds[0]);
 792     ASSERT_EQ(layerIds[1], screenProperties.layerIds[1]);
 793     ASSERT_EQ(layerIds[2], screenProperties.layerIds[2]);
 794
 795     ASSERT_GT(screenProperties.screenWidth, 0u);
 796     ASSERT_GT(screenProperties.screenHeight, 0u);
 797
 798     t_ilm_uint numberOfHardwareLayers;
 799     ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
 800     ASSERT_EQ(numberOfHardwareLayers, screenProperties.harwareLayerCount);
 801
 802     // cleanup
 803     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[0]));
 804     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[1]));
 805     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIds[2]));
 806 }
 807
 808 TEST_F(IlmCommandTest, DisplaySetRenderOrder_growing) {
 809     //prepare needed layers
 810     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 811     t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
 812
 813     for (unsigned int i = 0; i < layerCount; ++i)
 814     {
 815         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
 816         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 817     }
 818
 819     t_ilm_display* screenIDs;
 820     t_ilm_uint screenCount;
 821     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
 822
 823     for(unsigned int i = 0; i < screenCount; ++i)
 824     {
 825         t_ilm_display screen = screenIDs[i];
 826         ilmScreenProperties screenProps;
 827
 828         //trying different render orders with increasing sizes
 829         for (unsigned int j = layerCount; j <= layerCount; --j) // note: using overflow here
 830         {
 831             //put them from end to beginning, so that in each loop iteration the order of layers change
 832             ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
 833             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 834             ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
 835
 836             ASSERT_EQ(layerCount - j, screenProps.layerCount);
 837             for(unsigned int k = 0; k < layerCount - j; ++k)
 838             {
 839                 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
 840             }
 841         }
 842     }
 843
 844     // cleanup
 845     for (unsigned int i = 0; i < layerCount; ++i)
 846     {
 847         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(renderOrder[i]));
 848     }
 849 }
 850
 851 TEST_F(IlmCommandTest, DisplaySetRenderOrder_shrinking) {
 852     //prepare needed layers
 853     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 854     t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
 855
 856     for (unsigned int i = 0; i < layerCount; ++i)
 857     {
 858         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
 859         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 860     }
 861
 862     t_ilm_display* screenIDs;
 863     t_ilm_uint screenCount;
 864     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
 865
 866     for(unsigned int i = 0; i < screenCount; ++i)
 867     {
 868         t_ilm_display screen = screenIDs[i];
 869         ilmScreenProperties screenProps;
 870
 871         //trying different render orders with decreasing sizes
 872         for (unsigned int j = 0; j <= layerCount; ++j)
 873         {
 874             //put them from end to beginning, so that in each loop iteration the order of layers change
 875             ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
 876             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 877             ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
 878
 879             ASSERT_EQ(layerCount - j, screenProps.layerCount);
 880             for(unsigned int k = 0; k < layerCount - j; ++k)
 881             {
 882                 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
 883             }
 884         }
 885     }
 886
 887     // cleanup
 888     for (unsigned int i = 0; i < layerCount; ++i)
 889     {
 890         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(renderOrder[i]));
 891     }
 892 }
 893
 894 TEST_F(IlmCommandTest, LayerSetRenderOrder_growing) {
 895     //prepare needed layers and surfaces
 896     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 897     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
 898
 899     for (unsigned int i = 0; i < surfaceCount; ++i)
 900     {
 901         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
 902         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 903     }
 904
 905     t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 906     t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
 907
 908     for (unsigned int i = 0; i < layerCount; ++i)
 909     {
 910         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
 911         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 912     }
 913
 914     t_ilm_display* screenIDs;
 915     t_ilm_uint screenCount;
 916     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
 917
 918     for(unsigned int i = 0; i < layerCount; ++i)
 919     {
 920         t_ilm_layer layer = layerIDs[i];
 921
 922         t_ilm_int layerSurfaceCount;
 923         t_ilm_surface* layerSurfaceIDs;
 924
 925         //trying different render orders with increasing sizes
 926         for (unsigned int j = surfaceCount; j <= surfaceCount; --j) // note: using overflow here
 927         {
 928             //put them from end to beginning, so that in each loop iteration the order of surafces change
 929             ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
 930             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 931             ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
 932
 933             ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
 934             for(unsigned int k = 0; k < surfaceCount - j; ++k)
 935             {
 936                 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
 937             }
 938         }
 939
 940         //set empty render order again
 941         ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
 942         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 943     }
 944
 945     // cleanup
 946     for (unsigned int i = 0; i < surfaceCount; ++i)
 947     {
 948         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
 949     }
 950     for (unsigned int i = 0; i < layerCount; ++i)
 951     {
 952         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIDs[i]));
 953     }
 954 }
 955
 956 TEST_F(IlmCommandTest, LayerSetRenderOrder_shrinking) {
 957     //prepare needed layers and surfaces
 958     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 959     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
 960
 961     for (unsigned int i = 0; i < surfaceCount; ++i)
 962     {
 963         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
 964         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 965     }
 966
 967     t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
 968     t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
 969
 970     for (unsigned int i = 0; i < layerCount; ++i)
 971     {
 972         ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
 973         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 974     }
 975
 976     t_ilm_display* screenIDs;
 977     t_ilm_uint screenCount;
 978     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
 979
 980     for(unsigned int i = 0; i < layerCount; ++i)
 981     {
 982         t_ilm_layer layer = layerIDs[i];
 983
 984         t_ilm_int layerSurfaceCount;
 985         t_ilm_surface* layerSurfaceIDs;
 986
 987         //trying different render orders with decreasing sizes
 988         for (unsigned int j = 0; j <= layerCount; ++j)
 989         {
 990             //put them from end to beginning, so that in each loop iteration the order of surafces change
 991             ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
 992             ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
 993             ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
 994
 995             ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
 996             for(unsigned int k = 0; k < surfaceCount - j; ++k)
 997             {
 998                 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
 999             }
1000         }
1001
1002         //set empty render order again
1003         ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1004         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1005     }
1006
1007     // cleanup
1008     for (unsigned int i = 0; i < surfaceCount; ++i)
1009     {
1010         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1011     }
1012     for (unsigned int i = 0; i < layerCount; ++i)
1013     {
1014         ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layerIDs[i]));
1015     }
1016 }
1017
1018 TEST_F(IlmCommandTest, LayerSetRenderOrder_duplicates) {
1019     //prepare needed layers and surfaces
1020     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1021     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1022
1023     for (unsigned int i = 0; i < surfaceCount; ++i)
1024     {
1025         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1026         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1027     }
1028
1029     t_ilm_surface duplicateRenderOrder[] = {renderOrder[0], renderOrder[1], renderOrder[0], renderOrder[1], renderOrder[0]};
1030     t_ilm_int duplicateSurfaceCount = sizeof(duplicateRenderOrder) / sizeof(duplicateRenderOrder[0]);
1031
1032     t_ilm_layer layer;
1033     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1034     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1035
1036     t_ilm_display* screenIDs;
1037     t_ilm_uint screenCount;
1038     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1039
1040     t_ilm_int layerSurfaceCount;
1041     t_ilm_surface* layerSurfaceIDs;
1042
1043     //trying duplicates
1044     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, duplicateRenderOrder, duplicateSurfaceCount));
1045     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1046     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1047
1048     ASSERT_EQ(2, layerSurfaceCount);
1049
1050     // cleanup
1051     for (unsigned int i = 0; i < surfaceCount; ++i)
1052     {
1053         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1054     }
1055     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
1056 }
1057
1058 TEST_F(IlmCommandTest, LayerSetRenderOrder_empty) {
1059     //prepare needed layers and surfaces
1060     t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1061     t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1062
1063     for (unsigned int i = 0; i < surfaceCount; ++i)
1064     {
1065         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurface, 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1066         ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1067     }
1068
1069     t_ilm_layer layer;
1070     ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1071     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1072
1073
1074     t_ilm_display* screenIDs;
1075     t_ilm_uint screenCount;
1076     ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1077
1078     t_ilm_int layerSurfaceCount;
1079     t_ilm_surface* layerSurfaceIDs;
1080
1081     //test start
1082     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, surfaceCount));
1083     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1084
1085     //set empty render order
1086     ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1087     ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1088     ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1089
1090     ASSERT_EQ(0, layerSurfaceCount);
1091
1092     // cleanup
1093     for (unsigned int i = 0; i < surfaceCount; ++i)
1094     {
1095         ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(renderOrder[i]));
1096     }
1097     ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
1098 }