LayerManagerClient/ilmControl/tests/ilm_control_test.cpp

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