1 /***************************************************************************
3 * Copyright 2010-2014 BMW Car IT GmbH
4 * Copyright (C) 2012 DENSO CORPORATION and Robert Bosch Car Multimedia Gmbh
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 ****************************************************************************/
21 #include <gtest/gtest.h>
26 #include "ilm_client.h"
27 #include "ilm_control.h"
31 bool contains(T const *actual, size_t as, T expected)
33 for (unsigned i = 0; i < as; i++)
34 if (actual[i] == expected)
39 class IlmCommandTest : public TestBase, public ::testing::Test {
43 ASSERT_EQ(ILM_SUCCESS, ilm_initWithNativedisplay((t_ilm_nativedisplay)wlDisplay));
48 //print_lmc_get_scene();
49 t_ilm_layer* layers = NULL;
51 EXPECT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&numLayer, &layers));
52 for (t_ilm_int i=0; i<numLayer; i++)
54 EXPECT_EQ(ILM_SUCCESS, ilm_layerRemove(layers[i]));
58 t_ilm_surface* surfaces = NULL;
59 t_ilm_int numSurfaces=0;
60 EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&numSurfaces, &surfaces));
61 for (t_ilm_int i=0; i<numSurfaces; i++)
63 EXPECT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surfaces[i]));
67 EXPECT_EQ(ILM_SUCCESS, ilm_commitChanges());
68 EXPECT_EQ(ILM_SUCCESS, ilm_destroy());
72 TEST_F(IlmCommandTest, SetGetSurfaceDimension) {
75 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 10, 10, ILM_PIXELFORMAT_RGBA_8888, &surface));
77 t_ilm_uint dim[2] = {15, 25};
78 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDimension(surface, dim));
79 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
81 t_ilm_uint dimreturned[2];
82 EXPECT_EQ(ILM_SUCCESS, ilm_surfaceGetDimension(surface, dimreturned));
83 EXPECT_EQ(dim[0], dimreturned[0]);
84 EXPECT_EQ(dim[1], dimreturned[1]);
87 TEST_F(IlmCommandTest, SetGetSurfaceDimension_InvalidInput) {
88 uint surface = 0xdeadbeef;
89 t_ilm_uint dim[2] = {15, 25};
91 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetDimension(surface, dim));
92 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetDimension(surface, dim));
95 TEST_F(IlmCommandTest, SetGetLayerDimension) {
98 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
100 t_ilm_uint dim[2] = {115, 125};
101 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDimension(layer, dim));
102 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
104 t_ilm_uint dimreturned[2];
105 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetDimension(layer, dimreturned));
106 EXPECT_EQ(dim[0], dimreturned[0]);
107 EXPECT_EQ(dim[1], dimreturned[1]);
110 TEST_F(IlmCommandTest, SetGetLayerDimension_InvalidInput) {
111 uint layer = 0xdeadbeef;
112 t_ilm_uint dim[2] = {115, 125};
114 ASSERT_NE(ILM_SUCCESS, ilm_layerSetDimension(layer, dim));
115 ASSERT_NE(ILM_SUCCESS, ilm_layerGetDimension(layer, dim));
118 TEST_F(IlmCommandTest, SetGetSurfacePosition) {
121 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 10, 10, ILM_PIXELFORMAT_RGBA_8888, &surface));
123 t_ilm_uint pos[2] = {15, 25};
124 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetPosition(surface, pos));
125 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
127 t_ilm_uint posreturned[2];
128 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPosition(surface, posreturned));
129 EXPECT_EQ(pos[0], posreturned[0]);
130 EXPECT_EQ(pos[1], posreturned[1]);
133 TEST_F(IlmCommandTest, SetGetSurfacePosition_InvalidInput) {
134 uint surface = 0xdeadbeef;
135 t_ilm_uint pos[2] = {15, 25};
136 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetPosition(surface, pos));
137 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetPosition(surface, pos));
140 TEST_F(IlmCommandTest, SetGetLayerPosition) {
143 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
145 t_ilm_uint pos[2] = {115, 125};
146 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetPosition(layer, pos));
147 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
149 t_ilm_uint posreturned[2];
150 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetPosition(layer, posreturned));
151 ASSERT_EQ(pos[0], posreturned[0]);
152 ASSERT_EQ(pos[1], posreturned[1]);
155 TEST_F(IlmCommandTest, SetGetLayerPosition_InvalidInput) {
156 uint layer = 0xdeadbeef;
157 t_ilm_uint pos[2] = {15, 25};
158 ASSERT_NE(ILM_SUCCESS, ilm_layerSetPosition(layer, pos));
159 ASSERT_NE(ILM_SUCCESS, ilm_layerGetPosition(layer, pos));
162 TEST_F(IlmCommandTest, SetGetSurfaceOrientation) {
164 ilmOrientation returned;
165 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
167 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
168 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
169 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
170 ASSERT_EQ(ILM_NINETY, returned);
172 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ONEHUNDREDEIGHTY));
173 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
174 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
175 ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
177 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
178 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
179 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
180 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
182 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_ZERO));
183 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
184 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOrientation(surface, &returned));
185 ASSERT_EQ(ILM_ZERO, returned);
188 TEST_F(IlmCommandTest, SetGetLayerOrientation) {
190 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
191 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
192 ilmOrientation returned;
194 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
195 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
196 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
197 ASSERT_EQ(ILM_NINETY, returned);
199 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ONEHUNDREDEIGHTY));
200 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
201 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
202 ASSERT_EQ(ILM_ONEHUNDREDEIGHTY, returned);
204 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
205 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
206 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
207 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, returned);
209 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_ZERO));
210 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
211 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOrientation(layer, &returned));
212 ASSERT_EQ(ILM_ZERO, returned);
215 TEST_F(IlmCommandTest, SetGetSurfaceOpacity) {
220 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
221 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
223 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface1, 0.88));
224 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
225 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface1, &opacity));
226 EXPECT_NEAR(0.88, opacity, 0.01);
228 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface2, 0.001));
229 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
230 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetOpacity(surface2, &opacity));
231 EXPECT_NEAR(0.001, opacity, 0.01);
234 TEST_F(IlmCommandTest, SetGetSurfaceOpacity_InvalidInput) {
235 t_ilm_uint surface = 0xdeadbeef;
238 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.88));
239 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetOpacity(surface, &opacity));
242 TEST_F(IlmCommandTest, SetGetLayerOpacity) {
247 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
248 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
250 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer1, 0.88));
251 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
252 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer1, &opacity));
253 EXPECT_NEAR(0.88, opacity, 0.01);
255 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer2, 0.001));
256 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
257 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetOpacity(layer2, &opacity));
258 EXPECT_NEAR(0.001, opacity, 0.01);
261 TEST_F(IlmCommandTest, SetGetLayerOpacity_InvalidInput) {
262 t_ilm_layer layer = 0xdeadbeef;
265 ASSERT_NE(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.88));
266 ASSERT_NE(ILM_SUCCESS, ilm_layerGetOpacity(layer, &opacity));
269 TEST_F(IlmCommandTest, SetGetSurfaceVisibility) {
271 t_ilm_bool visibility;
273 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
275 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
276 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
277 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
278 ASSERT_EQ(ILM_TRUE, visibility);
280 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_FALSE));
281 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
282 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
283 ASSERT_EQ(ILM_FALSE, visibility);
285 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
286 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
287 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
288 ASSERT_EQ(ILM_TRUE, visibility);
291 TEST_F(IlmCommandTest, SetGetSurfaceVisibility_InvalidInput) {
292 uint surface = 0xdeadbeef;
293 t_ilm_bool visibility;
295 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetVisibility(surface, &visibility));
296 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_TRUE));
297 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, ILM_FALSE));
300 TEST_F(IlmCommandTest, SetGetLayerVisibility) {
302 t_ilm_bool visibility;
304 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
306 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
307 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
308 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
309 ASSERT_EQ(ILM_TRUE, visibility);
311 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_FALSE));
312 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
313 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
314 ASSERT_EQ(ILM_FALSE, visibility);
316 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
317 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
318 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
319 ASSERT_EQ(ILM_TRUE, visibility);
322 TEST_F(IlmCommandTest, SetGetLayerVisibility_InvalidInput) {
323 uint layer = 0xdeadbeef;
324 t_ilm_bool visibility;
326 ASSERT_NE(ILM_SUCCESS, ilm_layerGetVisibility(layer, &visibility));
327 ASSERT_NE(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_TRUE));
328 ASSERT_NE(ILM_SUCCESS, ilm_layerSetVisibility(layer, ILM_FALSE));
331 TEST_F(IlmCommandTest, SetSurfaceSourceRectangle) {
332 t_ilm_uint surface = 0xbeef;
333 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
334 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
336 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
337 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
339 ilmSurfaceProperties surfaceProperties;
340 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
341 ASSERT_EQ(89u, surfaceProperties.sourceX);
342 ASSERT_EQ(6538u, surfaceProperties.sourceY);
343 ASSERT_EQ(638u, surfaceProperties.sourceWidth);
344 ASSERT_EQ(4u, surfaceProperties.sourceHeight);
348 TEST_F(IlmCommandTest, SetSurfaceSourceRectangle_InvalidInput) {
349 ASSERT_NE(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(0xdeadbeef, 89, 6538, 638, 4));
352 TEST_F(IlmCommandTest, ilm_getScreenIDs) {
353 t_ilm_uint numberOfScreens = 0;
354 t_ilm_uint* screenIDs = NULL;
355 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
356 EXPECT_GT(numberOfScreens, 0u);
360 TEST_F(IlmCommandTest, ilm_getScreenResolution_SingleScreen) {
361 t_ilm_uint numberOfScreens = 0;
362 t_ilm_uint* screenIDs = NULL;
363 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
365 ASSERT_TRUE(numberOfScreens>0);
367 uint firstScreen = screenIDs[0];
368 t_ilm_uint width = 0, height = 0;
369 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(firstScreen, &width, &height));
370 ASSERT_GT(width, 0u);
371 ASSERT_GT(height, 0u);
374 TEST_F(IlmCommandTest, ilm_getScreenResolution_MultiScreen) {
375 t_ilm_uint numberOfScreens = 0;
376 t_ilm_uint* screenIDs = NULL;
377 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
379 ASSERT_TRUE(numberOfScreens>0);
381 for (uint screenIndex = 0; screenIndex < numberOfScreens; ++screenIndex)
383 uint screen = screenIDs[screenIndex];
384 t_ilm_uint width = 0, height = 0;
385 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenResolution(screen, &width, &height));
386 ASSERT_GT(width, 0u);
387 ASSERT_GT(height, 0u);
391 TEST_F(IlmCommandTest, ilm_getLayerIDs) {
395 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
396 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
397 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
401 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
403 EXPECT_EQ(layer1, IDs[0]);
404 EXPECT_EQ(layer2, IDs[1]);
408 TEST_F(IlmCommandTest, ilm_getLayerIDsOfScreen) {
409 t_ilm_layer layer1 = 3246;
410 t_ilm_layer layer2 = 46586;
411 t_ilm_uint roLength = 2;
412 t_ilm_layer idRenderOrder[2] = {layer1, layer2};
413 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
414 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
415 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(0, idRenderOrder, roLength));
416 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
418 t_ilm_int length = 0;
419 t_ilm_layer* IDs = 0;
420 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDsOnScreen(0, &length, &IDs));
422 EXPECT_EQ(2, length);
425 EXPECT_EQ(layer1, IDs[0]);
426 EXPECT_EQ(layer2, IDs[1]);
431 TEST_F(IlmCommandTest, ilm_getSurfaceIDs) {
432 uint surface1 = 3246;
433 uint surface2 = 46586;
435 t_ilm_int old_length;
437 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&old_length, &IDs));
438 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
439 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
440 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
444 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
446 EXPECT_EQ(old_length+2, length);
447 if (length == old_length+2)
449 EXPECT_TRUE(contains(IDs+old_length, 2, surface1));
450 EXPECT_TRUE(contains(IDs+old_length, 2, surface2));
455 TEST_F(IlmCommandTest, ilm_surfaceCreate_Remove) {
456 uint surface1 = 3246;
457 uint surface2 = 46586;
458 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
459 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
460 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
464 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
466 EXPECT_EQ(length, 2);
469 EXPECT_TRUE(contains(IDs, 2, surface1));
470 EXPECT_TRUE(contains(IDs, 2, surface2));
474 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
475 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
476 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
477 EXPECT_EQ(length, 1);
480 EXPECT_EQ(surface2, IDs[0]);
484 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
485 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
486 EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
487 EXPECT_EQ(length, 0);
491 TEST_F(IlmCommandTest, ilm_layerCreate_Remove) {
494 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
495 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
496 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
500 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
502 EXPECT_EQ(length, 2);
505 EXPECT_EQ(layer1, IDs[0]);
506 EXPECT_EQ(layer2, IDs[1]);
510 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
511 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
512 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
513 EXPECT_EQ(length, 1);
516 EXPECT_EQ(layer2, IDs[0]);
520 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
521 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
522 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
523 EXPECT_EQ(length, 0);
527 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidInput) {
528 ASSERT_NE(ILM_SUCCESS, ilm_layerRemove(0xdeadbeef));
531 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidUse) {
534 t_ilm_int orig_length;
537 // get the initial number of layers
538 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&orig_length, &IDs));
542 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
543 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
544 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
546 ASSERT_EQ(length, orig_length+1);
548 // remove the new layer
549 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
550 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
551 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
553 ASSERT_EQ(length, orig_length);
555 // try to remove the same layer once more
556 ASSERT_NE(ILM_SUCCESS, ilm_layerRemove(layer));
559 TEST_F(IlmCommandTest, ilm_layerGetType) {
560 t_ilm_uint layer = 0xbeef;
563 // add a layer and check its type
564 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
565 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
566 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(layer, &type));
567 ASSERT_EQ(ILM_LAYERTYPE_SOFTWARE2D, type);
570 TEST_F(IlmCommandTest, ilm_layerGetType_InvalidInput) {
573 // check type of a non-existing layer
574 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(0xdeadbeef, &type));
575 ASSERT_EQ(ILM_LAYERTYPE_UNKNOWN, type);
578 TEST_F(IlmCommandTest, ilm_layerGetCapabilities) {
579 t_ilm_uint layer = 0xbeef;
580 t_ilm_layercapabilities caps;
582 t_ilm_layercapabilities exp_caps = 0;
584 // add a layer and check its capabilities
585 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
586 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
587 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetCapabilities(layer, &caps));
588 ASSERT_EQ(exp_caps, caps);
591 TEST_F(IlmCommandTest, ilm_layerTypeGetCapabilities) {
592 t_ilm_layercapabilities caps;
594 t_ilm_layercapabilities exp_caps = 0;
596 // check ILM_LAYERTYPE_UNKNOWN
598 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_UNKNOWN, &caps));
599 ASSERT_EQ(exp_caps, caps);
601 // check ILM_LAYERTYPE_HARDWARE
603 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_HARDWARE, &caps));
604 ASSERT_EQ(exp_caps, caps);
606 // check ILM_LAYERTYPE_SOFTWARE2D
608 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2D, &caps));
609 ASSERT_EQ(exp_caps, caps);
611 // check ILM_LAYERTYPE_SOFTWARE2_5D
613 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2_5D, &caps));
614 ASSERT_EQ(exp_caps, caps);
617 TEST_F(IlmCommandTest, ilm_surface_initialize) {
618 uint surface_10 = 10;
619 uint surface_20 = 20;
620 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_10));
621 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_20));
625 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
627 EXPECT_EQ(length, 2);
630 EXPECT_EQ(surface_10, IDs[0]);
631 EXPECT_EQ(surface_20, IDs[1]);
636 TEST_F(IlmCommandTest, ilm_layerAddSurface_ilm_layerRemoveSurface_ilm_getSurfaceIDsOnLayer) {
638 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
639 uint surface1 = 3246;
640 uint surface2 = 46586;
641 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
642 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
643 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
647 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
649 ASSERT_EQ(length, 0);
651 ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface1));
652 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
653 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
654 EXPECT_EQ(length, 1);
657 EXPECT_EQ(surface1, IDs[0]);
661 ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface2));
662 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
663 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
664 EXPECT_EQ(length, 2);
667 EXPECT_EQ(surface1, IDs[0]);
668 EXPECT_EQ(surface2, IDs[1]);
672 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface1));
673 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
674 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
675 EXPECT_EQ(length, 1);
678 EXPECT_EQ(surface2, IDs[0]);
682 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface2));
683 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
684 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
686 ASSERT_EQ(length, 0);
689 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidInput) {
690 uint layer = 0xdeadbeef;
694 ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
697 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidResources) {
699 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
700 uint surface1 = 0xbeef1;
701 uint surface2 = 0xbeef2;
702 uint surface3 = 0xbeef3;
703 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
704 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
705 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[2], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface3));
706 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
713 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, IDs, 3));
714 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
716 ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, NULL));
719 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_ilm_surfaceSetSourceRectangle_ilm_surfaceSetDestinationRectangle) {
720 t_ilm_uint surface = 0xbeef;
721 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
722 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
724 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.8765));
725 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
726 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 54, 47, 947, 9));
727 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
728 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, true));
729 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
731 ilmSurfaceProperties surfaceProperties;
732 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
733 ASSERT_NEAR(0.8765, surfaceProperties.opacity, 0.1);
734 ASSERT_EQ(89u, surfaceProperties.sourceX);
735 ASSERT_EQ(6538u, surfaceProperties.sourceY);
736 ASSERT_EQ(638u, surfaceProperties.sourceWidth);
737 ASSERT_EQ(4u, surfaceProperties.sourceHeight);
738 ASSERT_EQ(54u, surfaceProperties.destX);
739 ASSERT_EQ(47u, surfaceProperties.destY);
740 ASSERT_EQ(947u, surfaceProperties.destWidth);
741 ASSERT_EQ(9u, surfaceProperties.destHeight);
742 ASSERT_EQ(ILM_NINETY, surfaceProperties.orientation);
743 ASSERT_TRUE( surfaceProperties.visibility);
745 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.436));
746 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 784, 546, 235, 78));
747 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 536, 5372, 3, 4316));
748 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
749 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, false));
750 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
752 ilmSurfaceProperties surfaceProperties2;
753 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties2));
754 ASSERT_NEAR(0.436, surfaceProperties2.opacity, 0.1);
755 ASSERT_EQ(784u, surfaceProperties2.sourceX);
756 ASSERT_EQ(546u, surfaceProperties2.sourceY);
757 ASSERT_EQ(235u, surfaceProperties2.sourceWidth);
758 ASSERT_EQ(78u, surfaceProperties2.sourceHeight);
759 ASSERT_EQ(536u, surfaceProperties2.destX);
760 ASSERT_EQ(5372u, surfaceProperties2.destY);
761 ASSERT_EQ(3u, surfaceProperties2.destWidth);
762 ASSERT_EQ(4316u, surfaceProperties2.destHeight);
763 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, surfaceProperties2.orientation);
764 ASSERT_FALSE(surfaceProperties2.visibility);
767 TEST_F(IlmCommandTest, ilm_getPropertiesOfLayer_ilm_layerSetSourceRectangle_ilm_layerSetDestinationRectangle) {
768 t_ilm_uint layer = 0xbeef;
769 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
770 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
772 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.8765));
773 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 89, 6538, 638, 4));
774 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 54, 47, 947, 9));
775 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
776 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, true));
777 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
779 ilmLayerProperties layerProperties1;
780 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties1));
781 ASSERT_NEAR(0.8765, layerProperties1.opacity, 0.1);
782 ASSERT_EQ(89u, layerProperties1.sourceX);
783 ASSERT_EQ(6538u, layerProperties1.sourceY);
784 ASSERT_EQ(638u, layerProperties1.sourceWidth);
785 ASSERT_EQ(4u, layerProperties1.sourceHeight);
786 ASSERT_EQ(54u, layerProperties1.destX);
787 ASSERT_EQ(47u, layerProperties1.destY);
788 ASSERT_EQ(947u, layerProperties1.destWidth);
789 ASSERT_EQ(9u, layerProperties1.destHeight);
790 ASSERT_EQ(ILM_NINETY, layerProperties1.orientation);
791 ASSERT_TRUE( layerProperties1.visibility);
793 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.436));
794 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 784, 546, 235, 78));
795 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 536, 5372, 3, 4316));
796 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
797 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, false));
798 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
800 ilmLayerProperties layerProperties2;
801 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties2));
802 ASSERT_NEAR(0.436, layerProperties2.opacity, 0.1);
803 ASSERT_EQ(784u, layerProperties2.sourceX);
804 ASSERT_EQ(546u, layerProperties2.sourceY);
805 ASSERT_EQ(235u, layerProperties2.sourceWidth);
806 ASSERT_EQ(78u, layerProperties2.sourceHeight);
807 ASSERT_EQ(536u, layerProperties2.destX);
808 ASSERT_EQ(5372u, layerProperties2.destY);
809 ASSERT_EQ(3u, layerProperties2.destWidth);
810 ASSERT_EQ(4316u, layerProperties2.destHeight);
811 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, layerProperties2.orientation);
812 ASSERT_FALSE(layerProperties2.visibility);
815 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_InvalidInput) {
816 ilmSurfaceProperties surfaceProperties;
817 ASSERT_NE(ILM_SUCCESS, ilm_getPropertiesOfSurface(0xdeadbeef, &surfaceProperties));
820 TEST_F(IlmCommandTest, ilm_takeScreenshot) {
821 const char* outputFile = "/tmp/test.bmp";
822 // make sure the file is not there before
823 FILE* f = fopen(outputFile, "r");
826 int result = remove(outputFile);
827 ASSERT_EQ(0, result);
830 ASSERT_EQ(ILM_SUCCESS, ilm_takeScreenshot(0, outputFile));
833 f = fopen(outputFile, "r");
834 ASSERT_TRUE(f!=NULL);
839 TEST_F(IlmCommandTest, ilm_takeScreenshot_InvalidInputs) {
840 const char* outputFile = "/tmp/test.bmp";
841 // make sure the file is not there before
842 FILE* f = fopen(outputFile, "r");
845 ASSERT_EQ(0, remove(outputFile));
848 // try to dump an non-existing screen
849 ASSERT_NE(ILM_SUCCESS, ilm_takeScreenshot(0xdeadbeef, outputFile));
851 // make sure, no screen dump file was created for invalid screen
852 ASSERT_NE(0, remove(outputFile));
855 TEST_F(IlmCommandTest, ilm_takeLayerScreenshot) {
856 const char* outputFile = "/tmp/test.bmp";
857 // make sure the file is not there before
858 FILE* f = fopen(outputFile, "r");
861 int result = remove(outputFile);
862 ASSERT_EQ(0, result);
865 t_ilm_layer layer = 0xbeef;
866 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
867 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
868 ASSERT_EQ(ILM_SUCCESS, ilm_takeLayerScreenshot(outputFile, layer));
871 f = fopen(outputFile, "r");
872 ASSERT_TRUE(f!=NULL);
875 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
878 TEST_F(IlmCommandTest, ilm_takeLayerScreenshot_InvalidInputs) {
879 const char* outputFile = "/tmp/test.bmp";
880 // make sure the file is not there before
881 FILE* f = fopen(outputFile, "r");
884 ASSERT_EQ(0, remove(outputFile));
887 // try to dump an non-existing screen
888 ASSERT_NE(ILM_SUCCESS, ilm_takeLayerScreenshot(outputFile, 0xdeadbeef));
890 // make sure, no screen dump file was created for invalid screen
891 ASSERT_NE(0, remove(outputFile));
894 TEST_F(IlmCommandTest, ilm_takeSurfaceScreenshot) {
895 const char* outputFile = "/tmp/test.bmp";
896 // make sure the file is not there before
897 FILE* f = fopen(outputFile, "r");
900 int result = remove(outputFile);
901 ASSERT_EQ(0, result);
904 t_ilm_surface surface = 0xbeef;
905 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
906 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
907 ASSERT_EQ(ILM_SUCCESS, ilm_takeSurfaceScreenshot(outputFile, surface));
910 f = fopen(outputFile, "r");
911 ASSERT_TRUE(f!=NULL);
914 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
917 TEST_F(IlmCommandTest, ilm_takeSurfaceScreenshot_InvalidInputs) {
918 const char* outputFile = "/tmp/test.bmp";
919 // make sure the file is not there before
920 FILE* f = fopen(outputFile, "r");
923 ASSERT_EQ(0, remove(outputFile));
926 // try to dump an non-existing screen
927 ASSERT_NE(ILM_SUCCESS, ilm_takeSurfaceScreenshot(outputFile, 0xdeadbeef));
929 // make sure, no screen dump file was created for invalid screen
930 ASSERT_NE(0, remove(outputFile));
933 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat) {
934 t_ilm_uint surface1=0;
935 t_ilm_uint surface2=1;
936 t_ilm_uint surface3=2;
937 t_ilm_uint surface4=3;
938 t_ilm_uint surface5=4;
939 t_ilm_uint surface6=5;
940 t_ilm_uint surface7=6;
942 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_4444, &surface1));
943 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_5551, &surface2));
944 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[2], 0, 0, ILM_PIXELFORMAT_RGBA_6661, &surface3));
945 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[3], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface4));
946 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[4], 0, 0, ILM_PIXELFORMAT_RGB_565, &surface5));
947 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[5], 0, 0, ILM_PIXELFORMAT_RGB_888, &surface6));
948 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[6], 0, 0, ILM_PIXELFORMAT_R_8, &surface7));
949 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
951 ilmPixelFormat p1, p2, p3, p4, p5, p6, p7;
953 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface1, &p1));
954 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface2, &p2));
955 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface3, &p3));
956 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface4, &p4));
957 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface5, &p5));
958 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface6, &p6));
959 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface7, &p7));
961 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_4444, p1);
962 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_5551, p2);
963 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_6661, p3);
964 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_8888, p4);
965 ASSERT_EQ(ILM_PIXELFORMAT_RGB_565, p5);
966 ASSERT_EQ(ILM_PIXELFORMAT_RGB_888, p6);
967 ASSERT_EQ(ILM_PIXELFORMAT_R_8, p7);
970 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat_InvalidInput) {
972 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetPixelformat(0xdeadbeef, &p));
975 TEST_F(IlmCommandTest, ilm_keyboard_focus) {
980 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
981 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
983 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
984 EXPECT_EQ(0xFFFFFFFF, surface);
986 ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
987 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
988 EXPECT_EQ(surface1, surface);
991 TEST_F(IlmCommandTest, ilm_input_event_acceptance) {
995 ilmSurfaceProperties surfaceProperties;
997 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
998 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
1000 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1001 EXPECT_EQ(ILM_INPUT_DEVICE_ALL, surfaceProperties.inputDevicesAcceptance);
1003 ASSERT_EQ(ILM_SUCCESS, ilm_UpdateInputEventAcceptanceOn(surface1, (ilmInputDevice) (ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_POINTER), false));
1004 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1007 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1008 EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_KEYBOARD);
1009 EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_POINTER);
1010 EXPECT_TRUE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_TOUCH);
1012 ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
1013 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
1014 EXPECT_NE(surface1, surface);
1017 TEST_F(IlmCommandTest, SetGetOptimizationMode) {
1019 ilmOptimizationMode mode;
1020 ilmOptimizationMode retmode;
1022 id = ILM_OPT_MULTITEXTURE;
1023 mode = ILM_OPT_MODE_FORCE_OFF;
1024 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1025 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1026 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1027 ASSERT_EQ(mode, retmode);
1029 id = ILM_OPT_SKIP_CLEAR;
1030 mode = ILM_OPT_MODE_TOGGLE;
1031 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1032 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1033 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1034 ASSERT_EQ(mode, retmode);
1036 id = ILM_OPT_MULTITEXTURE;
1037 mode = ILM_OPT_MODE_HEURISTIC;
1038 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1039 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1040 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1041 ASSERT_EQ(mode, retmode);
1044 TEST_F(IlmCommandTest, ilm_getNumberOfHardwareLayers) {
1045 t_ilm_uint numberOfScreens = 0;
1046 t_ilm_uint* screenIDs = NULL;
1047 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
1048 ASSERT_TRUE(numberOfScreens>0);
1050 t_ilm_display screen = screenIDs[0];
1051 t_ilm_uint numberOfHardwareLayers;
1053 // Depends on the platform the test is executed on - just check if the
1054 // function doesn't fail. The ilm_getPropertiesOfScreen test does a more
1055 // comprehensive verification.
1056 ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
1057 ASSERT_GT(numberOfHardwareLayers, 0u);
1060 TEST_F(IlmCommandTest, ilm_getPropertiesOfScreen) {
1061 t_ilm_uint numberOfScreens = 0;
1062 t_ilm_uint* screenIDs = NULL;
1063 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
1064 ASSERT_TRUE(numberOfScreens>0);
1066 t_ilm_display screen = screenIDs[0];
1067 ilmScreenProperties screenProperties;
1069 t_ilm_layer layerIds[3] = {100, 200, 300};//t_ilm_layer layerIds[3] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1070 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds, 800, 480));
1071 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 1, 800, 480));
1072 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 2, 800, 480));
1074 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1076 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, layerIds, 3));
1078 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1081 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProperties));
1082 ASSERT_EQ(3, screenProperties.layerCount);
1083 ASSERT_EQ(layerIds[0], screenProperties.layerIds[0]);
1084 ASSERT_EQ(layerIds[1], screenProperties.layerIds[1]);
1085 ASSERT_EQ(layerIds[2], screenProperties.layerIds[2]);
1087 ASSERT_GT(screenProperties.screenWidth, 0u);
1088 ASSERT_GT(screenProperties.screenHeight, 0u);
1090 t_ilm_uint numberOfHardwareLayers;
1091 ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
1092 ASSERT_EQ(numberOfHardwareLayers, screenProperties.harwareLayerCount);
1096 TEST_F(IlmCommandTest, DisplaySetRenderOrder_growing) {
1097 //prepare needed layers
1098 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1099 t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1101 for (unsigned int i = 0; i < layerCount; ++i)
1103 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1104 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1107 t_ilm_display* screenIDs;
1108 t_ilm_uint screenCount;
1109 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1111 for(unsigned int i = 0; i < screenCount; ++i)
1113 t_ilm_display screen = screenIDs[i];
1114 ilmScreenProperties screenProps;
1116 //trying different render orders with increasing sizes
1117 for (unsigned int j = layerCount; j <= layerCount; --j) // note: using overflow here
1119 //put them from end to beginning, so that in each loop iteration the order of layers change
1120 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1121 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1122 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1124 ASSERT_EQ(layerCount - j, screenProps.layerCount);
1125 for(unsigned int k = 0; k < layerCount - j; ++k)
1127 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1134 TEST_F(IlmCommandTest, DisplaySetRenderOrder_shrinking) {
1135 //prepare needed layers
1136 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1137 t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1139 for (unsigned int i = 0; i < layerCount; ++i)
1141 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1142 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1145 t_ilm_display* screenIDs;
1146 t_ilm_uint screenCount;
1147 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1149 for(unsigned int i = 0; i < screenCount; ++i)
1151 t_ilm_display screen = screenIDs[i];
1152 ilmScreenProperties screenProps;
1154 //trying different render orders with decreasing sizes
1155 for (unsigned int j = 0; j < layerCount; ++j)
1157 //put them from end to beginning, so that in each loop iteration the order of layers change
1158 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1159 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1160 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1162 ASSERT_EQ(layerCount - j, screenProps.layerCount);
1163 for(unsigned int k = 0; k < layerCount - j; ++k)
1165 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1172 TEST_F(IlmCommandTest, LayerSetRenderOrder_growing) {
1173 //prepare needed layers and surfaces
1174 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1175 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1177 for (unsigned int i = 0; i < surfaceCount; ++i)
1179 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1180 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1183 t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1184 t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1186 for (unsigned int i = 0; i < layerCount; ++i)
1188 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1189 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1192 t_ilm_display* screenIDs;
1193 t_ilm_uint screenCount;
1194 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1196 for(unsigned int i = 0; i < layerCount; ++i)
1198 t_ilm_layer layer = layerIDs[i];
1200 t_ilm_int layerSurfaceCount;
1201 t_ilm_surface* layerSurfaceIDs;
1203 //trying different render orders with increasing sizes
1204 for (unsigned int j = surfaceCount; j <= surfaceCount; --j) // note: using overflow here
1206 //put them from end to beginning, so that in each loop iteration the order of surafces change
1207 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1208 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1209 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1211 ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1212 for(unsigned int k = 0; k < surfaceCount - j; ++k)
1214 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1218 //set empty render order again
1219 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1220 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1225 TEST_F(IlmCommandTest, LayerSetRenderOrder_shrinking) {
1226 //prepare needed layers and surfaces
1227 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1228 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1230 for (unsigned int i = 0; i < surfaceCount; ++i)
1232 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1233 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1236 t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1237 t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1239 for (unsigned int i = 0; i < layerCount; ++i)
1241 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1242 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1245 t_ilm_display* screenIDs;
1246 t_ilm_uint screenCount;
1247 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1249 for(unsigned int i = 0; i < layerCount; ++i)
1251 t_ilm_layer layer = layerIDs[i];
1253 t_ilm_int layerSurfaceCount;
1254 t_ilm_surface* layerSurfaceIDs;
1256 //trying different render orders with decreasing sizes
1257 for (unsigned int j = 0; j < layerCount; ++j)
1259 //put them from end to beginning, so that in each loop iteration the order of surafces change
1260 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1261 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1262 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1264 ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1265 for(unsigned int k = 0; k < surfaceCount - j; ++k)
1267 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1271 //set empty render order again
1272 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1273 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1278 TEST_F(IlmCommandTest, LayerSetRenderOrder_duplicates) {
1279 //prepare needed layers and surfaces
1280 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1281 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1283 for (unsigned int i = 0; i < surfaceCount; ++i)
1285 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1286 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1289 t_ilm_surface duplicateRenderOrder[] = {renderOrder[0], renderOrder[1], renderOrder[0], renderOrder[1], renderOrder[0]};
1290 t_ilm_int duplicateSurfaceCount = sizeof(duplicateRenderOrder) / sizeof(duplicateRenderOrder[0]);
1293 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1294 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1296 t_ilm_display* screenIDs;
1297 t_ilm_uint screenCount;
1298 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1301 t_ilm_int layerSurfaceCount;
1302 t_ilm_surface* layerSurfaceIDs;
1305 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, duplicateRenderOrder, duplicateSurfaceCount));
1306 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1307 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1308 free(layerSurfaceIDs);
1310 ASSERT_EQ(2, layerSurfaceCount);
1313 TEST_F(IlmCommandTest, LayerSetRenderOrder_empty) {
1314 //prepare needed layers and surfaces
1315 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1316 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1318 for (unsigned int i = 0; i < surfaceCount; ++i)
1320 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1321 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1325 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1326 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1328 t_ilm_display* screenIDs;
1329 t_ilm_uint screenCount;
1330 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1333 t_ilm_int layerSurfaceCount;
1334 t_ilm_surface* layerSurfaceIDs;
1337 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, surfaceCount));
1338 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1340 //set empty render order
1341 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1342 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1343 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1344 free(layerSurfaceIDs);
1346 ASSERT_EQ(0, layerSurfaceCount);