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]);
409 TEST_F(IlmCommandTest, ilm_getLayerIDsOfScreen) {
410 t_ilm_layer layer1 = 3246;
411 t_ilm_layer layer2 = 46586;
412 t_ilm_uint roLength = 2;
413 t_ilm_layer idRenderOrder[2] = {layer1, layer2};
414 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
415 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
416 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(0, idRenderOrder, roLength));
417 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
419 t_ilm_int length = 0;
420 t_ilm_layer* IDs = 0;
421 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDsOnScreen(0, &length, &IDs));
423 EXPECT_EQ(2, length);
426 EXPECT_EQ(layer1, IDs[0]);
427 EXPECT_EQ(layer2, IDs[1]);
432 TEST_F(IlmCommandTest, ilm_getSurfaceIDs) {
433 uint surface1 = 3246;
434 uint surface2 = 46586;
436 t_ilm_int old_length;
438 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&old_length, &IDs));
439 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
440 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
441 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
445 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
447 EXPECT_EQ(old_length+2, length);
448 if (length == old_length+2)
450 EXPECT_TRUE(contains(IDs+old_length, 2, surface1));
451 EXPECT_TRUE(contains(IDs+old_length, 2, surface2));
457 TEST_F(IlmCommandTest, ilm_surfaceCreate_Remove) {
458 uint surface1 = 3246;
459 uint surface2 = 46586;
460 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
461 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
462 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
466 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
468 EXPECT_EQ(length, 2);
471 EXPECT_TRUE(contains(IDs, 2, surface1));
472 EXPECT_TRUE(contains(IDs, 2, surface2));
476 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface1));
477 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
478 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
479 EXPECT_EQ(length, 1);
482 EXPECT_EQ(surface2, IDs[0]);
486 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface2));
487 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
488 EXPECT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
489 EXPECT_EQ(length, 0);
493 TEST_F(IlmCommandTest, ilm_layerCreate_Remove) {
496 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer1, 800, 480));
497 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer2, 800, 480));
498 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
502 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
504 EXPECT_EQ(length, 2);
507 EXPECT_EQ(layer1, IDs[0]);
508 EXPECT_EQ(layer2, IDs[1]);
512 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer1));
513 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
514 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
515 EXPECT_EQ(length, 1);
518 EXPECT_EQ(layer2, IDs[0]);
522 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer2));
523 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
524 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
525 EXPECT_EQ(length, 0);
529 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidInput) {
530 ASSERT_NE(ILM_SUCCESS, ilm_layerRemove(0xdeadbeef));
533 TEST_F(IlmCommandTest, ilm_layerRemove_InvalidUse) {
536 t_ilm_int orig_length;
538 t_ilm_int new_length;
540 // get the initial number of layers
541 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&orig_length, &IDs));
545 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
546 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
547 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
549 ASSERT_EQ(length, orig_length+1);
551 // remove the new layer
552 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
553 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
554 ASSERT_EQ(ILM_SUCCESS, ilm_getLayerIDs(&length, &IDs));
556 ASSERT_EQ(length, orig_length);
558 // try to remove the same layer once more
559 ASSERT_NE(ILM_SUCCESS, ilm_layerRemove(layer));
562 TEST_F(IlmCommandTest, ilm_layerGetType) {
563 t_ilm_uint layer = 0xbeef;
566 // add a layer and check its type
567 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
568 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
569 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(layer, &type));
570 ASSERT_EQ(ILM_LAYERTYPE_SOFTWARE2D, type);
574 TEST_F(IlmCommandTest, ilm_layerGetType_InvalidInput) {
577 // check type of a non-existing layer
578 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetType(0xdeadbeef, &type));
579 ASSERT_EQ(ILM_LAYERTYPE_UNKNOWN, type);
582 TEST_F(IlmCommandTest, ilm_layerGetCapabilities) {
583 t_ilm_uint layer = 0xbeef;
584 t_ilm_layercapabilities caps;
586 t_ilm_layercapabilities exp_caps = 0;
588 // add a layer and check its capabilities
589 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
590 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
591 ASSERT_EQ(ILM_SUCCESS, ilm_layerGetCapabilities(layer, &caps));
592 ASSERT_EQ(exp_caps, caps);
596 TEST_F(IlmCommandTest, ilm_layerTypeGetCapabilities) {
597 t_ilm_layercapabilities caps;
599 t_ilm_layercapabilities exp_caps = 0;
601 // check ILM_LAYERTYPE_UNKNOWN
603 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_UNKNOWN, &caps));
604 ASSERT_EQ(exp_caps, caps);
606 // check ILM_LAYERTYPE_HARDWARE
608 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_HARDWARE, &caps));
609 ASSERT_EQ(exp_caps, caps);
611 // check ILM_LAYERTYPE_SOFTWARE2D
613 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2D, &caps));
614 ASSERT_EQ(exp_caps, caps);
616 // check ILM_LAYERTYPE_SOFTWARE2_5D
618 ASSERT_EQ(ILM_SUCCESS, ilm_layerTypeGetCapabilities(ILM_LAYERTYPE_SOFTWARE2_5D, &caps));
619 ASSERT_EQ(exp_caps, caps);
622 TEST_F(IlmCommandTest, ilm_surface_initialize) {
623 uint surface_10 = 10;
624 uint surface_20 = 20;
625 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_10));
626 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceInitialize(&surface_20));
630 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDs(&length, &IDs));
632 EXPECT_EQ(length, 2);
635 EXPECT_EQ(surface_10, IDs[0]);
636 EXPECT_EQ(surface_20, IDs[1]);
641 TEST_F(IlmCommandTest, ilm_layerAddSurface_ilm_layerRemoveSurface_ilm_getSurfaceIDsOnLayer) {
643 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
644 uint surface1 = 3246;
645 uint surface2 = 46586;
646 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
647 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
648 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
652 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
654 ASSERT_EQ(length, 0);
656 ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface1));
657 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
658 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
659 EXPECT_EQ(length, 1);
662 EXPECT_EQ(surface1, IDs[0]);
666 ASSERT_EQ(ILM_SUCCESS, ilm_layerAddSurface(layer, surface2));
667 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
668 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
669 EXPECT_EQ(length, 2);
672 EXPECT_EQ(surface1, IDs[0]);
673 EXPECT_EQ(surface2, IDs[1]);
677 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface1));
678 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
679 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
680 EXPECT_EQ(length, 1);
683 EXPECT_EQ(surface2, IDs[0]);
687 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemoveSurface(layer, surface2));
688 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
689 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
691 ASSERT_EQ(length, 0);
694 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidInput) {
695 uint layer = 0xdeadbeef;
699 ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, &IDs));
702 TEST_F(IlmCommandTest, ilm_getSurfaceIDsOnLayer_InvalidResources) {
704 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
705 uint surface1 = 0xbeef1;
706 uint surface2 = 0xbeef2;
707 uint surface3 = 0xbeef3;
708 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
709 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
710 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[2], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface3));
711 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
718 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, IDs, 3));
719 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
721 ASSERT_NE(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &length, NULL));
725 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_ilm_surfaceSetSourceRectangle_ilm_surfaceSetDestinationRectangle) {
726 t_ilm_uint surface = 0xbeef;
727 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
728 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
730 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.8765));
731 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 89, 6538, 638, 4));
732 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 54, 47, 947, 9));
733 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_NINETY));
734 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, true));
735 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
737 ilmSurfaceProperties surfaceProperties;
738 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties));
739 ASSERT_NEAR(0.8765, surfaceProperties.opacity, 0.1);
740 ASSERT_EQ(89u, surfaceProperties.sourceX);
741 ASSERT_EQ(6538u, surfaceProperties.sourceY);
742 ASSERT_EQ(638u, surfaceProperties.sourceWidth);
743 ASSERT_EQ(4u, surfaceProperties.sourceHeight);
744 ASSERT_EQ(54u, surfaceProperties.destX);
745 ASSERT_EQ(47u, surfaceProperties.destY);
746 ASSERT_EQ(947u, surfaceProperties.destWidth);
747 ASSERT_EQ(9u, surfaceProperties.destHeight);
748 ASSERT_EQ(ILM_NINETY, surfaceProperties.orientation);
749 ASSERT_TRUE( surfaceProperties.visibility);
751 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOpacity(surface, 0.436));
752 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetSourceRectangle(surface, 784, 546, 235, 78));
753 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetDestinationRectangle(surface, 536, 5372, 3, 4316));
754 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetOrientation(surface, ILM_TWOHUNDREDSEVENTY));
755 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceSetVisibility(surface, false));
756 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
758 ilmSurfaceProperties surfaceProperties2;
759 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface, &surfaceProperties2));
760 ASSERT_NEAR(0.436, surfaceProperties2.opacity, 0.1);
761 ASSERT_EQ(784u, surfaceProperties2.sourceX);
762 ASSERT_EQ(546u, surfaceProperties2.sourceY);
763 ASSERT_EQ(235u, surfaceProperties2.sourceWidth);
764 ASSERT_EQ(78u, surfaceProperties2.sourceHeight);
765 ASSERT_EQ(536u, surfaceProperties2.destX);
766 ASSERT_EQ(5372u, surfaceProperties2.destY);
767 ASSERT_EQ(3u, surfaceProperties2.destWidth);
768 ASSERT_EQ(4316u, surfaceProperties2.destHeight);
769 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, surfaceProperties2.orientation);
770 ASSERT_FALSE(surfaceProperties2.visibility);
774 TEST_F(IlmCommandTest, ilm_getPropertiesOfLayer_ilm_layerSetSourceRectangle_ilm_layerSetDestinationRectangle) {
775 t_ilm_uint layer = 0xbeef;
776 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
777 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
779 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.8765));
780 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 89, 6538, 638, 4));
781 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 54, 47, 947, 9));
782 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_NINETY));
783 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, true));
784 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
786 ilmLayerProperties layerProperties1;
787 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties1));
788 ASSERT_NEAR(0.8765, layerProperties1.opacity, 0.1);
789 ASSERT_EQ(89u, layerProperties1.sourceX);
790 ASSERT_EQ(6538u, layerProperties1.sourceY);
791 ASSERT_EQ(638u, layerProperties1.sourceWidth);
792 ASSERT_EQ(4u, layerProperties1.sourceHeight);
793 ASSERT_EQ(54u, layerProperties1.destX);
794 ASSERT_EQ(47u, layerProperties1.destY);
795 ASSERT_EQ(947u, layerProperties1.destWidth);
796 ASSERT_EQ(9u, layerProperties1.destHeight);
797 ASSERT_EQ(ILM_NINETY, layerProperties1.orientation);
798 ASSERT_TRUE( layerProperties1.visibility);
800 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOpacity(layer, 0.436));
801 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetSourceRectangle(layer, 784, 546, 235, 78));
802 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetDestinationRectangle(layer, 536, 5372, 3, 4316));
803 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetOrientation(layer, ILM_TWOHUNDREDSEVENTY));
804 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetVisibility(layer, false));
805 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
807 ilmLayerProperties layerProperties2;
808 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfLayer(layer, &layerProperties2));
809 ASSERT_NEAR(0.436, layerProperties2.opacity, 0.1);
810 ASSERT_EQ(784u, layerProperties2.sourceX);
811 ASSERT_EQ(546u, layerProperties2.sourceY);
812 ASSERT_EQ(235u, layerProperties2.sourceWidth);
813 ASSERT_EQ(78u, layerProperties2.sourceHeight);
814 ASSERT_EQ(536u, layerProperties2.destX);
815 ASSERT_EQ(5372u, layerProperties2.destY);
816 ASSERT_EQ(3u, layerProperties2.destWidth);
817 ASSERT_EQ(4316u, layerProperties2.destHeight);
818 ASSERT_EQ(ILM_TWOHUNDREDSEVENTY, layerProperties2.orientation);
819 ASSERT_FALSE(layerProperties2.visibility);
823 TEST_F(IlmCommandTest, ilm_getPropertiesOfSurface_InvalidInput) {
824 ilmSurfaceProperties surfaceProperties;
825 ASSERT_NE(ILM_SUCCESS, ilm_getPropertiesOfSurface(0xdeadbeef, &surfaceProperties));
828 TEST_F(IlmCommandTest, ilm_takeScreenshot) {
829 const char* outputFile = "/tmp/test.bmp";
830 // make sure the file is not there before
831 FILE* f = fopen(outputFile, "r");
834 int result = remove(outputFile);
835 ASSERT_EQ(0, result);
838 ASSERT_EQ(ILM_SUCCESS, ilm_takeScreenshot(0, outputFile));
841 f = fopen(outputFile, "r");
842 ASSERT_TRUE(f!=NULL);
847 TEST_F(IlmCommandTest, ilm_takeScreenshot_InvalidInputs) {
848 const char* outputFile = "/tmp/test.bmp";
849 // make sure the file is not there before
850 FILE* f = fopen(outputFile, "r");
853 ASSERT_EQ(0, remove(outputFile));
856 // try to dump an non-existing screen
857 ASSERT_NE(ILM_SUCCESS, ilm_takeScreenshot(0xdeadbeef, outputFile));
859 // make sure, no screen dump file was created for invalid screen
860 ASSERT_NE(0, remove(outputFile));
863 TEST_F(IlmCommandTest, ilm_takeLayerScreenshot) {
864 const char* outputFile = "/tmp/test.bmp";
865 // make sure the file is not there before
866 FILE* f = fopen(outputFile, "r");
869 int result = remove(outputFile);
870 ASSERT_EQ(0, result);
873 t_ilm_layer layer = 0xbeef;
874 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 800, 480));
875 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
876 ASSERT_EQ(ILM_SUCCESS, ilm_takeLayerScreenshot(outputFile, layer));
879 f = fopen(outputFile, "r");
880 ASSERT_TRUE(f!=NULL);
883 ASSERT_EQ(ILM_SUCCESS, ilm_layerRemove(layer));
886 TEST_F(IlmCommandTest, ilm_takeLayerScreenshot_InvalidInputs) {
887 const char* outputFile = "/tmp/test.bmp";
888 // make sure the file is not there before
889 FILE* f = fopen(outputFile, "r");
892 ASSERT_EQ(0, remove(outputFile));
895 // try to dump an non-existing screen
896 ASSERT_NE(ILM_SUCCESS, ilm_takeLayerScreenshot(outputFile, 0xdeadbeef));
898 // make sure, no screen dump file was created for invalid screen
899 ASSERT_NE(0, remove(outputFile));
902 TEST_F(IlmCommandTest, ilm_takeSurfaceScreenshot) {
903 const char* outputFile = "/tmp/test.bmp";
904 // make sure the file is not there before
905 FILE* f = fopen(outputFile, "r");
908 int result = remove(outputFile);
909 ASSERT_EQ(0, result);
912 t_ilm_surface surface = 0xbeef;
913 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface));
914 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
915 ASSERT_EQ(ILM_SUCCESS, ilm_takeSurfaceScreenshot(outputFile, surface));
918 f = fopen(outputFile, "r");
919 ASSERT_TRUE(f!=NULL);
922 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceRemove(surface));
925 TEST_F(IlmCommandTest, ilm_takeSurfaceScreenshot_InvalidInputs) {
926 const char* outputFile = "/tmp/test.bmp";
927 // make sure the file is not there before
928 FILE* f = fopen(outputFile, "r");
931 ASSERT_EQ(0, remove(outputFile));
934 // try to dump an non-existing screen
935 ASSERT_NE(ILM_SUCCESS, ilm_takeSurfaceScreenshot(outputFile, 0xdeadbeef));
937 // make sure, no screen dump file was created for invalid screen
938 ASSERT_NE(0, remove(outputFile));
941 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat) {
942 t_ilm_uint surface1=0;
943 t_ilm_uint surface2=1;
944 t_ilm_uint surface3=2;
945 t_ilm_uint surface4=3;
946 t_ilm_uint surface5=4;
947 t_ilm_uint surface6=5;
948 t_ilm_uint surface7=6;
950 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_4444, &surface1));
951 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_5551, &surface2));
952 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[2], 0, 0, ILM_PIXELFORMAT_RGBA_6661, &surface3));
953 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[3], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface4));
954 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[4], 0, 0, ILM_PIXELFORMAT_RGB_565, &surface5));
955 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[5], 0, 0, ILM_PIXELFORMAT_RGB_888, &surface6));
956 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[6], 0, 0, ILM_PIXELFORMAT_R_8, &surface7));
957 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
959 ilmPixelFormat p1, p2, p3, p4, p5, p6, p7;
961 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface1, &p1));
962 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface2, &p2));
963 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface3, &p3));
964 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface4, &p4));
965 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface5, &p5));
966 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface6, &p6));
967 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceGetPixelformat(surface7, &p7));
969 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_4444, p1);
970 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_5551, p2);
971 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_6661, p3);
972 ASSERT_EQ(ILM_PIXELFORMAT_RGBA_8888, p4);
973 ASSERT_EQ(ILM_PIXELFORMAT_RGB_565, p5);
974 ASSERT_EQ(ILM_PIXELFORMAT_RGB_888, p6);
975 ASSERT_EQ(ILM_PIXELFORMAT_R_8, p7);
979 TEST_F(IlmCommandTest, ilm_surfaceGetPixelformat_InvalidInput) {
981 ASSERT_NE(ILM_SUCCESS, ilm_surfaceGetPixelformat(0xdeadbeef, &p));
984 TEST_F(IlmCommandTest, ilm_keyboard_focus) {
989 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
990 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
992 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
993 EXPECT_EQ(0xFFFFFFFF, surface);
995 ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
996 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
997 EXPECT_EQ(surface1, surface);
1001 TEST_F(IlmCommandTest, ilm_input_event_acceptance) {
1005 ilmSurfaceProperties surfaceProperties;
1007 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[0], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface1));
1008 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[1], 0, 0, ILM_PIXELFORMAT_RGBA_8888, &surface2));
1010 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1011 EXPECT_EQ(ILM_INPUT_DEVICE_ALL, surfaceProperties.inputDevicesAcceptance);
1013 ASSERT_EQ(ILM_SUCCESS, ilm_UpdateInputEventAcceptanceOn(surface1, (ilmInputDevice) (ILM_INPUT_DEVICE_KEYBOARD | ILM_INPUT_DEVICE_POINTER), false));
1014 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1017 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfSurface(surface1, &surfaceProperties));
1018 EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_KEYBOARD);
1019 EXPECT_FALSE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_POINTER);
1020 EXPECT_TRUE(surfaceProperties.inputDevicesAcceptance & ILM_INPUT_DEVICE_TOUCH);
1022 ASSERT_EQ(ILM_SUCCESS, ilm_SetKeyboardFocusOn(surface1));
1023 ASSERT_EQ(ILM_SUCCESS, ilm_GetKeyboardFocusSurfaceId(&surface));
1024 EXPECT_NE(surface1, surface);
1028 TEST_F(IlmCommandTest, SetGetOptimizationMode) {
1030 ilmOptimizationMode mode;
1031 ilmOptimizationMode retmode;
1033 id = ILM_OPT_MULTITEXTURE;
1034 mode = ILM_OPT_MODE_FORCE_OFF;
1035 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1036 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1037 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1038 ASSERT_EQ(mode, retmode);
1040 id = ILM_OPT_SKIP_CLEAR;
1041 mode = ILM_OPT_MODE_TOGGLE;
1042 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1043 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1044 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1045 ASSERT_EQ(mode, retmode);
1047 id = ILM_OPT_MULTITEXTURE;
1048 mode = ILM_OPT_MODE_HEURISTIC;
1049 ASSERT_EQ(ILM_SUCCESS, ilm_SetOptimizationMode(id, mode));
1050 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1051 ASSERT_EQ(ILM_SUCCESS, ilm_GetOptimizationMode(id, &retmode));
1052 ASSERT_EQ(mode, retmode);
1055 TEST_F(IlmCommandTest, ilm_getNumberOfHardwareLayers) {
1056 t_ilm_uint numberOfScreens = 0;
1057 t_ilm_uint* screenIDs = NULL;
1058 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
1059 ASSERT_TRUE(numberOfScreens>0);
1061 t_ilm_display screen = screenIDs[0];
1062 t_ilm_uint numberOfHardwareLayers;
1064 // Depends on the platform the test is executed on - just check if the
1065 // function doesn't fail. The ilm_getPropertiesOfScreen test does a more
1066 // comprehensive verification.
1067 ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
1068 ASSERT_GT(numberOfHardwareLayers, 0u);
1071 TEST_F(IlmCommandTest, ilm_getPropertiesOfScreen) {
1072 t_ilm_uint numberOfScreens = 0;
1073 t_ilm_uint* screenIDs = NULL;
1074 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&numberOfScreens, &screenIDs));
1075 ASSERT_TRUE(numberOfScreens>0);
1077 t_ilm_display screen = screenIDs[0];
1078 ilmScreenProperties screenProperties;
1080 t_ilm_layer layerIds[3] = {100, 200, 300};//t_ilm_layer layerIds[3] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1081 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds, 800, 480));
1082 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 1, 800, 480));
1083 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIds + 2, 800, 480));
1085 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1087 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, layerIds, 3));
1089 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1092 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProperties));
1093 ASSERT_EQ(3, screenProperties.layerCount);
1094 ASSERT_EQ(layerIds[0], screenProperties.layerIds[0]);
1095 ASSERT_EQ(layerIds[1], screenProperties.layerIds[1]);
1096 ASSERT_EQ(layerIds[2], screenProperties.layerIds[2]);
1098 ASSERT_GT(screenProperties.screenWidth, 0u);
1099 ASSERT_GT(screenProperties.screenHeight, 0u);
1101 t_ilm_uint numberOfHardwareLayers;
1102 ASSERT_EQ(ILM_SUCCESS, ilm_getNumberOfHardwareLayers(screen, &numberOfHardwareLayers));
1103 ASSERT_EQ(numberOfHardwareLayers, screenProperties.harwareLayerCount);
1107 TEST_F(IlmCommandTest, DisplaySetRenderOrder_growing) {
1108 //prepare needed layers
1109 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1110 t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1112 for (unsigned int i = 0; i < layerCount; ++i)
1114 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1115 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1118 t_ilm_display* screenIDs;
1119 t_ilm_uint screenCount;
1120 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1122 for(unsigned int i = 0; i < screenCount; ++i)
1124 t_ilm_display screen = screenIDs[i];
1125 ilmScreenProperties screenProps;
1127 //trying different render orders with increasing sizes
1128 for (unsigned int j = layerCount; j <= layerCount; --j) // note: using overflow here
1130 //put them from end to beginning, so that in each loop iteration the order of layers change
1131 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1132 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1133 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1135 ASSERT_EQ(layerCount - j, screenProps.layerCount);
1136 for(unsigned int k = 0; k < layerCount - j; ++k)
1138 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1145 TEST_F(IlmCommandTest, DisplaySetRenderOrder_shrinking) {
1146 //prepare needed layers
1147 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1148 t_ilm_uint layerCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1150 for (unsigned int i = 0; i < layerCount; ++i)
1152 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(renderOrder + i, 300, 300));
1153 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1156 t_ilm_display* screenIDs;
1157 t_ilm_uint screenCount;
1158 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1160 for(unsigned int i = 0; i < screenCount; ++i)
1162 t_ilm_display screen = screenIDs[i];
1163 ilmScreenProperties screenProps;
1165 //trying different render orders with decreasing sizes
1166 for (unsigned int j = 0; j < layerCount; ++j)
1168 //put them from end to beginning, so that in each loop iteration the order of layers change
1169 ASSERT_EQ(ILM_SUCCESS, ilm_displaySetRenderOrder(screen, renderOrder + j, layerCount - j));
1170 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1171 ASSERT_EQ(ILM_SUCCESS, ilm_getPropertiesOfScreen(screen, &screenProps));
1173 ASSERT_EQ(layerCount - j, screenProps.layerCount);
1174 for(unsigned int k = 0; k < layerCount - j; ++k)
1176 ASSERT_EQ(renderOrder[j + k], screenProps.layerIds[k]);
1183 TEST_F(IlmCommandTest, LayerSetRenderOrder_growing) {
1184 //prepare needed layers and surfaces
1185 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1186 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1188 for (unsigned int i = 0; i < surfaceCount; ++i)
1190 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1191 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1194 t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1195 t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1197 for (unsigned int i = 0; i < layerCount; ++i)
1199 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1200 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1203 t_ilm_display* screenIDs;
1204 t_ilm_uint screenCount;
1205 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1207 for(unsigned int i = 0; i < layerCount; ++i)
1209 t_ilm_layer layer = layerIDs[i];
1211 t_ilm_int layerSurfaceCount;
1212 t_ilm_surface* layerSurfaceIDs;
1214 //trying different render orders with increasing sizes
1215 for (unsigned int j = surfaceCount; j <= surfaceCount; --j) // note: using overflow here
1217 //put them from end to beginning, so that in each loop iteration the order of surafces change
1218 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1219 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1220 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1222 ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1223 for(unsigned int k = 0; k < surfaceCount - j; ++k)
1225 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1229 //set empty render order again
1230 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1231 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1236 TEST_F(IlmCommandTest, LayerSetRenderOrder_shrinking) {
1237 //prepare needed layers and surfaces
1238 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1239 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1241 for (unsigned int i = 0; i < surfaceCount; ++i)
1243 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1244 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1247 t_ilm_layer layerIDs[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1248 t_ilm_uint layerCount = sizeof(layerIDs) / sizeof(layerIDs[0]);
1250 for (unsigned int i = 0; i < layerCount; ++i)
1252 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(layerIDs + i, 300, 300));
1253 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1256 t_ilm_display* screenIDs;
1257 t_ilm_uint screenCount;
1258 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1260 for(unsigned int i = 0; i < layerCount; ++i)
1262 t_ilm_layer layer = layerIDs[i];
1264 t_ilm_int layerSurfaceCount;
1265 t_ilm_surface* layerSurfaceIDs;
1267 //trying different render orders with decreasing sizes
1268 for (unsigned int j = 0; j < layerCount; ++j)
1270 //put them from end to beginning, so that in each loop iteration the order of surafces change
1271 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder + j, surfaceCount - j));
1272 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1273 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1275 ASSERT_EQ(surfaceCount - j, layerSurfaceCount);
1276 for(unsigned int k = 0; k < surfaceCount - j; ++k)
1278 ASSERT_EQ(renderOrder[j + k], layerSurfaceIDs[k]);
1282 //set empty render order again
1283 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1284 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1289 TEST_F(IlmCommandTest, LayerSetRenderOrder_duplicates) {
1290 //prepare needed layers and surfaces
1291 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1292 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1294 for (unsigned int i = 0; i < surfaceCount; ++i)
1296 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1297 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1300 t_ilm_surface duplicateRenderOrder[] = {renderOrder[0], renderOrder[1], renderOrder[0], renderOrder[1], renderOrder[0]};
1301 t_ilm_int duplicateSurfaceCount = sizeof(duplicateRenderOrder) / sizeof(duplicateRenderOrder[0]);
1304 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1305 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1307 t_ilm_display* screenIDs;
1308 t_ilm_uint screenCount;
1309 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1312 t_ilm_int layerSurfaceCount;
1313 t_ilm_surface* layerSurfaceIDs;
1316 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, duplicateRenderOrder, duplicateSurfaceCount));
1317 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1318 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1319 free(layerSurfaceIDs);
1321 ASSERT_EQ(2, layerSurfaceCount);
1325 TEST_F(IlmCommandTest, LayerSetRenderOrder_empty) {
1326 //prepare needed layers and surfaces
1327 t_ilm_layer renderOrder[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
1328 t_ilm_uint surfaceCount = sizeof(renderOrder) / sizeof(renderOrder[0]);
1330 for (unsigned int i = 0; i < surfaceCount; ++i)
1332 ASSERT_EQ(ILM_SUCCESS, ilm_surfaceCreate((t_ilm_nativehandle)wlSurfaces[i], 100, 100, ILM_PIXELFORMAT_RGBA_8888, renderOrder + i));
1333 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1337 ASSERT_EQ(ILM_SUCCESS, ilm_layerCreateWithDimension(&layer, 300, 300));
1338 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1340 t_ilm_display* screenIDs;
1341 t_ilm_uint screenCount;
1342 ASSERT_EQ(ILM_SUCCESS, ilm_getScreenIDs(&screenCount, &screenIDs));
1345 t_ilm_int layerSurfaceCount;
1346 t_ilm_surface* layerSurfaceIDs;
1349 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, surfaceCount));
1350 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1352 //set empty render order
1353 ASSERT_EQ(ILM_SUCCESS, ilm_layerSetRenderOrder(layer, renderOrder, 0));
1354 ASSERT_EQ(ILM_SUCCESS, ilm_commitChanges());
1355 ASSERT_EQ(ILM_SUCCESS, ilm_getSurfaceIDsOnLayer(layer, &layerSurfaceCount, &layerSurfaceIDs));
1356 free(layerSurfaceIDs);
1358 ASSERT_EQ(0, layerSurfaceCount);