source: mainline/uspace/lib/ipcgfx/test/ipcgfx.c@ 7cc30e9

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7cc30e9 was 7470d97, checked in by Jiri Svoboda <jiri@…>, 5 years ago

Add GC operation to set clipping rectangle

The number of changed files is due to the proliferation of GC
implementations, mostly these are just dummies in unit tests.
Definitely need to tame those in the future.
  • Property mode set to 100644
File size: 31.6 KB
RevLine 
[38e4f42]1/*
[2ab8ab3]2 * Copyright (c) 2021 Jiri Svoboda
[38e4f42]3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
[afcf704]29#include <as.h>
[38e4f42]30#include <async.h>
31#include <errno.h>
32#include <gfx/bitmap.h>
33#include <gfx/color.h>
34#include <gfx/coord.h>
35#include <gfx/context.h>
36#include <gfx/render.h>
37#include <ipcgfx/client.h>
38#include <ipcgfx/server.h>
39#include <loc.h>
40#include <pcut/pcut.h>
41#include <stdint.h>
42
43PCUT_INIT;
44
45PCUT_TEST_SUITE(ipcgfx);
46
47static const char *test_ipcgfx_server = "test-ipcgfx";
48static const char *test_ipcgfx_svc = "test/ipcgfx";
49
50static void test_ipcgc_conn(ipc_call_t *, void *);
51
[7470d97]52static errno_t test_gc_set_clip_rect(void *, gfx_rect_t *);
[38e4f42]53static errno_t test_gc_set_color(void *, gfx_color_t *);
54static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
[2ab8ab3]55static errno_t test_gc_update(void *);
[38e4f42]56static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
57 gfx_bitmap_alloc_t *, void **);
58static errno_t test_gc_bitmap_destroy(void *);
59static errno_t test_gc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
60static errno_t test_gc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
61
62static gfx_context_ops_t test_gc_ops = {
[7470d97]63 .set_clip_rect = test_gc_set_clip_rect,
[38e4f42]64 .set_color = test_gc_set_color,
65 .fill_rect = test_gc_fill_rect,
[2ab8ab3]66 .update = test_gc_update,
[38e4f42]67 .bitmap_create = test_gc_bitmap_create,
68 .bitmap_destroy = test_gc_bitmap_destroy,
69 .bitmap_render = test_gc_bitmap_render,
70 .bitmap_get_alloc = test_gc_bitmap_get_alloc
71};
72
73/** Describes to the server how to respond to our request and pass tracking
74 * data back to the client.
75 */
76typedef struct {
77 errno_t rc;
78
[7470d97]79 bool set_clip_rect_called;
80 bool do_clip;
81 gfx_rect_t set_clip_rect_rect;
82
[38e4f42]83 bool set_color_called;
84 uint16_t set_color_r;
85 uint16_t set_color_g;
86 uint16_t set_color_b;
87
88 bool fill_rect_called;
89 gfx_rect_t fill_rect_rect;
90
[2ab8ab3]91 bool update_called;
92
[38e4f42]93 bool bitmap_create_called;
94 gfx_bitmap_params_t bitmap_create_params;
95 gfx_bitmap_alloc_t bitmap_create_alloc;
96
97 bool bitmap_destroy_called;
98
99 bool bitmap_render_called;
100 gfx_rect_t bitmap_render_srect;
101 gfx_coord2_t bitmap_render_offs;
102
103 bool bitmap_get_alloc_called;
104} test_response_t;
105
106/** Bitmap in test GC */
107typedef struct {
108 test_response_t *resp;
[afcf704]109 gfx_bitmap_alloc_t alloc;
[38e4f42]110} test_bitmap_t;
111
[7470d97]112/** gfx_set_clip_rect with server returning failure */
113PCUT_TEST(set_clip_rect_failure)
114{
115 errno_t rc;
116 service_id_t sid;
117 test_response_t resp;
118 gfx_context_t *gc;
119 gfx_rect_t rect;
120 async_sess_t *sess;
121 ipc_gc_t *ipcgc;
122
123 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
124
125 // FIXME This causes this test to be non-reentrant!
126 rc = loc_server_register(test_ipcgfx_server);
127 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
128
129 rc = loc_service_register(test_ipcgfx_svc, &sid);
130 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
131
132 sess = loc_service_connect(sid, INTERFACE_GC, 0);
133 PCUT_ASSERT_NOT_NULL(sess);
134
135 rc = ipc_gc_create(sess, &ipcgc);
136 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
137
138 gc = ipc_gc_get_ctx(ipcgc);
139 PCUT_ASSERT_NOT_NULL(gc);
140
141 resp.rc = ENOMEM;
142 resp.set_clip_rect_called = false;
143 rect.p0.x = 1;
144 rect.p0.y = 2;
145 rect.p1.x = 3;
146 rect.p1.y = 4;
147 rc = gfx_set_clip_rect(gc, &rect);
148 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
149 PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
150 PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
151 PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
152 PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
153 PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
154
155 ipc_gc_delete(ipcgc);
156 async_hangup(sess);
157
158 rc = loc_service_unregister(sid);
159 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
160}
161
162/** gfx_set_clip_rect with server returning success */
163PCUT_TEST(set_clip_rect_success)
164{
165 errno_t rc;
166 service_id_t sid;
167 test_response_t resp;
168 gfx_context_t *gc;
169 gfx_rect_t rect;
170 async_sess_t *sess;
171 ipc_gc_t *ipcgc;
172
173 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
174
175 // FIXME This causes this test to be non-reentrant!
176 rc = loc_server_register(test_ipcgfx_server);
177 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
178
179 rc = loc_service_register(test_ipcgfx_svc, &sid);
180 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
181
182 sess = loc_service_connect(sid, INTERFACE_GC, 0);
183 PCUT_ASSERT_NOT_NULL(sess);
184
185 rc = ipc_gc_create(sess, &ipcgc);
186 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
187
188 gc = ipc_gc_get_ctx(ipcgc);
189 PCUT_ASSERT_NOT_NULL(gc);
190
191 resp.rc = EOK;
192 resp.set_clip_rect_called = false;
193 rect.p0.x = 1;
194 rect.p0.y = 2;
195 rect.p1.x = 3;
196 rect.p1.y = 4;
197 rc = gfx_set_clip_rect(gc, &rect);
198 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
199 PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
200 PCUT_ASSERT_TRUE(resp.do_clip);
201 PCUT_ASSERT_EQUALS(rect.p0.x, resp.set_clip_rect_rect.p0.x);
202 PCUT_ASSERT_EQUALS(rect.p0.y, resp.set_clip_rect_rect.p0.y);
203 PCUT_ASSERT_EQUALS(rect.p1.x, resp.set_clip_rect_rect.p1.x);
204 PCUT_ASSERT_EQUALS(rect.p1.y, resp.set_clip_rect_rect.p1.y);
205
206 ipc_gc_delete(ipcgc);
207 async_hangup(sess);
208
209 rc = loc_service_unregister(sid);
210 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
211}
212
213/** gfx_set_clip_rect with null rectangle, server returning success */
214PCUT_TEST(set_clip_rect_null_success)
215{
216 errno_t rc;
217 service_id_t sid;
218 test_response_t resp;
219 gfx_context_t *gc;
220 async_sess_t *sess;
221 ipc_gc_t *ipcgc;
222
223 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
224
225 // FIXME This causes this test to be non-reentrant!
226 rc = loc_server_register(test_ipcgfx_server);
227 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
228
229 rc = loc_service_register(test_ipcgfx_svc, &sid);
230 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
231
232 sess = loc_service_connect(sid, INTERFACE_GC, 0);
233 PCUT_ASSERT_NOT_NULL(sess);
234
235 rc = ipc_gc_create(sess, &ipcgc);
236 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
237
238 gc = ipc_gc_get_ctx(ipcgc);
239 PCUT_ASSERT_NOT_NULL(gc);
240
241 resp.rc = EOK;
242 resp.set_clip_rect_called = false;
243
244 rc = gfx_set_clip_rect(gc, NULL);
245 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
246 PCUT_ASSERT_TRUE(resp.set_clip_rect_called);
247 PCUT_ASSERT_FALSE(resp.do_clip);
248
249 ipc_gc_delete(ipcgc);
250 async_hangup(sess);
251
252 rc = loc_service_unregister(sid);
253 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
254}
255
[38e4f42]256/** gfx_set_color with server returning failure */
257PCUT_TEST(set_color_failure)
258{
259 errno_t rc;
260 service_id_t sid;
261 test_response_t resp;
262 gfx_context_t *gc;
263 gfx_color_t *color;
264 async_sess_t *sess;
265 ipc_gc_t *ipcgc;
266
267 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
268
269 // FIXME This causes this test to be non-reentrant!
270 rc = loc_server_register(test_ipcgfx_server);
271 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
272
273 rc = loc_service_register(test_ipcgfx_svc, &sid);
274 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
275
276 sess = loc_service_connect(sid, INTERFACE_GC, 0);
277 PCUT_ASSERT_NOT_NULL(sess);
278
279 rc = ipc_gc_create(sess, &ipcgc);
280 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
281
282 gc = ipc_gc_get_ctx(ipcgc);
283 PCUT_ASSERT_NOT_NULL(gc);
284
285 rc = gfx_color_new_rgb_i16(1, 2, 3, &color);
286 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
287
288 resp.rc = ENOMEM;
289 resp.set_color_called = false;
290 rc = gfx_set_color(gc, color);
291 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
292 PCUT_ASSERT_TRUE(resp.set_color_called);
293 PCUT_ASSERT_EQUALS(1, resp.set_color_r);
294 PCUT_ASSERT_EQUALS(2, resp.set_color_g);
295 PCUT_ASSERT_EQUALS(3, resp.set_color_b);
296
297 gfx_color_delete(color);
298
299 ipc_gc_delete(ipcgc);
300 async_hangup(sess);
301
302 rc = loc_service_unregister(sid);
303 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
304}
305
306/** gfx_set_color with server returning success */
307PCUT_TEST(set_color_success)
308{
309 errno_t rc;
310 service_id_t sid;
311 test_response_t resp;
312 gfx_context_t *gc;
313 gfx_color_t *color;
314 async_sess_t *sess;
315 ipc_gc_t *ipcgc;
316
317 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
318
319 // FIXME This causes this test to be non-reentrant!
320 rc = loc_server_register(test_ipcgfx_server);
321 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
322
323 rc = loc_service_register(test_ipcgfx_svc, &sid);
324 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
325
326 sess = loc_service_connect(sid, INTERFACE_GC, 0);
327 PCUT_ASSERT_NOT_NULL(sess);
328
329 rc = ipc_gc_create(sess, &ipcgc);
330 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
331
332 gc = ipc_gc_get_ctx(ipcgc);
333 PCUT_ASSERT_NOT_NULL(gc);
334
335 rc = gfx_color_new_rgb_i16(1, 2, 3, &color);
336 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
337
338 resp.rc = EOK;
339 resp.set_color_called = false;
340 rc = gfx_set_color(gc, color);
341 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
342 PCUT_ASSERT_TRUE(resp.set_color_called);
343 PCUT_ASSERT_EQUALS(1, resp.set_color_r);
344 PCUT_ASSERT_EQUALS(2, resp.set_color_g);
345 PCUT_ASSERT_EQUALS(3, resp.set_color_b);
346
347 gfx_color_delete(color);
348
349 ipc_gc_delete(ipcgc);
350 async_hangup(sess);
351
352 rc = loc_service_unregister(sid);
353 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
354}
355
356/** gfx_fill_rect with server returning failure */
357PCUT_TEST(fill_rect_failure)
358{
359 errno_t rc;
360 service_id_t sid;
361 test_response_t resp;
362 gfx_context_t *gc;
363 gfx_rect_t rect;
364 async_sess_t *sess;
365 ipc_gc_t *ipcgc;
366
367 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
368
369 // FIXME This causes this test to be non-reentrant!
370 rc = loc_server_register(test_ipcgfx_server);
371 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
372
373 rc = loc_service_register(test_ipcgfx_svc, &sid);
374 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
375
376 sess = loc_service_connect(sid, INTERFACE_GC, 0);
377 PCUT_ASSERT_NOT_NULL(sess);
378
379 rc = ipc_gc_create(sess, &ipcgc);
380 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
381
382 gc = ipc_gc_get_ctx(ipcgc);
383 PCUT_ASSERT_NOT_NULL(gc);
384
385 resp.rc = ENOMEM;
[7470d97]386 resp.fill_rect_called = false;
[38e4f42]387 rect.p0.x = 1;
388 rect.p0.y = 2;
389 rect.p1.x = 3;
390 rect.p1.y = 4;
391 rc = gfx_fill_rect(gc, &rect);
392 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
393 PCUT_ASSERT_TRUE(resp.fill_rect_called);
394 PCUT_ASSERT_EQUALS(rect.p0.x, resp.fill_rect_rect.p0.x);
395 PCUT_ASSERT_EQUALS(rect.p0.y, resp.fill_rect_rect.p0.y);
396 PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
397 PCUT_ASSERT_EQUALS(rect.p1.y, resp.fill_rect_rect.p1.y);
398
399 ipc_gc_delete(ipcgc);
400 async_hangup(sess);
401
402 rc = loc_service_unregister(sid);
403 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
404}
405
406/** gfx_fill_rect with server returning success */
407PCUT_TEST(fill_rect_success)
408{
409 errno_t rc;
410 service_id_t sid;
411 test_response_t resp;
412 gfx_context_t *gc;
413 gfx_rect_t rect;
414 async_sess_t *sess;
415 ipc_gc_t *ipcgc;
416
417 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
418
419 // FIXME This causes this test to be non-reentrant!
420 rc = loc_server_register(test_ipcgfx_server);
421 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
422
423 rc = loc_service_register(test_ipcgfx_svc, &sid);
424 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
425
426 sess = loc_service_connect(sid, INTERFACE_GC, 0);
427 PCUT_ASSERT_NOT_NULL(sess);
428
429 rc = ipc_gc_create(sess, &ipcgc);
430 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
431
432 gc = ipc_gc_get_ctx(ipcgc);
433 PCUT_ASSERT_NOT_NULL(gc);
434
435 resp.rc = EOK;
[7470d97]436 resp.fill_rect_called = false;
[38e4f42]437 rect.p0.x = 1;
438 rect.p0.y = 2;
439 rect.p1.x = 3;
440 rect.p1.y = 4;
441 rc = gfx_fill_rect(gc, &rect);
442 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
443 PCUT_ASSERT_TRUE(resp.fill_rect_called);
444 PCUT_ASSERT_EQUALS(rect.p0.x, resp.fill_rect_rect.p0.x);
445 PCUT_ASSERT_EQUALS(rect.p0.y, resp.fill_rect_rect.p0.y);
446 PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
447 PCUT_ASSERT_EQUALS(rect.p1.y, resp.fill_rect_rect.p1.y);
448
449 ipc_gc_delete(ipcgc);
450 async_hangup(sess);
451
452 rc = loc_service_unregister(sid);
453 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
454}
455
[2ab8ab3]456/** gfx_update with server returning failure */
457PCUT_TEST(update_failure)
458{
459 errno_t rc;
460 service_id_t sid;
461 test_response_t resp;
462 gfx_context_t *gc;
463 async_sess_t *sess;
464 ipc_gc_t *ipcgc;
465
466 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
467
468 // FIXME This causes this test to be non-reentrant!
469 rc = loc_server_register(test_ipcgfx_server);
470 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
471
472 rc = loc_service_register(test_ipcgfx_svc, &sid);
473 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
474
475 sess = loc_service_connect(sid, INTERFACE_GC, 0);
476 PCUT_ASSERT_NOT_NULL(sess);
477
478 rc = ipc_gc_create(sess, &ipcgc);
479 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
480
481 gc = ipc_gc_get_ctx(ipcgc);
482 PCUT_ASSERT_NOT_NULL(gc);
483
484 resp.rc = ENOMEM;
485 resp.update_called = false;
486 rc = gfx_update(gc);
487 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
488 PCUT_ASSERT_TRUE(resp.update_called);
489
490 ipc_gc_delete(ipcgc);
491 async_hangup(sess);
492
493 rc = loc_service_unregister(sid);
494 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
495}
496
497/** gfx_update with server returning success */
498PCUT_TEST(update_success)
499{
500 errno_t rc;
501 service_id_t sid;
502 test_response_t resp;
503 gfx_context_t *gc;
504 async_sess_t *sess;
505 ipc_gc_t *ipcgc;
506
507 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
508
509 // FIXME This causes this test to be non-reentrant!
510 rc = loc_server_register(test_ipcgfx_server);
511 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
512
513 rc = loc_service_register(test_ipcgfx_svc, &sid);
514 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
515
516 sess = loc_service_connect(sid, INTERFACE_GC, 0);
517 PCUT_ASSERT_NOT_NULL(sess);
518
519 rc = ipc_gc_create(sess, &ipcgc);
520 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
521
522 gc = ipc_gc_get_ctx(ipcgc);
523 PCUT_ASSERT_NOT_NULL(gc);
524
525 resp.rc = EOK;
526 resp.update_called = false;
527 rc = gfx_update(gc);
528 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
529 PCUT_ASSERT_TRUE(resp.update_called);
530
531 ipc_gc_delete(ipcgc);
532 async_hangup(sess);
533
534 rc = loc_service_unregister(sid);
535 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
536}
537
[38e4f42]538/** gfx_bitmap_create with server returning failure */
539PCUT_TEST(bitmap_create_failure)
540{
541 errno_t rc;
542 service_id_t sid;
543 test_response_t resp;
544 gfx_context_t *gc;
545 gfx_bitmap_params_t params;
546 gfx_bitmap_t *bitmap;
547 async_sess_t *sess;
548 ipc_gc_t *ipcgc;
549
550 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
551
552 // FIXME This causes this test to be non-reentrant!
553 rc = loc_server_register(test_ipcgfx_server);
554 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
555
556 rc = loc_service_register(test_ipcgfx_svc, &sid);
557 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
558
559 sess = loc_service_connect(sid, INTERFACE_GC, 0);
560 PCUT_ASSERT_NOT_NULL(sess);
561
562 rc = ipc_gc_create(sess, &ipcgc);
563 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
564
565 gc = ipc_gc_get_ctx(ipcgc);
566 PCUT_ASSERT_NOT_NULL(gc);
567
568 resp.rc = ENOMEM;
569 resp.bitmap_create_called = false;
[a8eed5f]570
571 gfx_bitmap_params_init(&params);
[38e4f42]572 params.rect.p0.x = 1;
573 params.rect.p0.y = 2;
574 params.rect.p1.x = 3;
575 params.rect.p1.y = 4;
576 bitmap = NULL;
577 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
578 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
579 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
580 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
581 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
582 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
583 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
584 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
585 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
586 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
587 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
588 PCUT_ASSERT_NULL(bitmap);
589
590 ipc_gc_delete(ipcgc);
591 async_hangup(sess);
592
593 rc = loc_service_unregister(sid);
594 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
595}
596
597/** gfx_bitmap_create and gfx_bitmap_destroy with server returning success */
598PCUT_TEST(bitmap_create_destroy_success)
599{
600 errno_t rc;
601 service_id_t sid;
602 test_response_t resp;
603 gfx_context_t *gc;
604 gfx_bitmap_params_t params;
605 gfx_bitmap_t *bitmap;
606 async_sess_t *sess;
607 ipc_gc_t *ipcgc;
608
609 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
610
611 // FIXME This causes this test to be non-reentrant!
612 rc = loc_server_register(test_ipcgfx_server);
613 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
614
615 rc = loc_service_register(test_ipcgfx_svc, &sid);
616 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
617
618 sess = loc_service_connect(sid, INTERFACE_GC, 0);
619 PCUT_ASSERT_NOT_NULL(sess);
620
621 rc = ipc_gc_create(sess, &ipcgc);
622 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
623
624 gc = ipc_gc_get_ctx(ipcgc);
625 PCUT_ASSERT_NOT_NULL(gc);
626
627 resp.rc = EOK;
628 resp.bitmap_create_called = false;
[a8eed5f]629
630 gfx_bitmap_params_init(&params);
[38e4f42]631 params.rect.p0.x = 1;
632 params.rect.p0.y = 2;
633 params.rect.p1.x = 3;
634 params.rect.p1.y = 4;
635 bitmap = NULL;
636 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
637 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
638 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
639 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
640 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
641 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
642 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
643 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
644 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
645 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
646 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
647 PCUT_ASSERT_NOT_NULL(bitmap);
648
649 resp.bitmap_destroy_called = false;
650 rc = gfx_bitmap_destroy(bitmap);
651 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
652 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
653
654 ipc_gc_delete(ipcgc);
655 async_hangup(sess);
656
657 rc = loc_service_unregister(sid);
658 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
659}
660
661/** gfx_bitmap_destroy with server returning failure */
662PCUT_TEST(bitmap_destroy_failure)
663{
664 errno_t rc;
665 service_id_t sid;
666 test_response_t resp;
667 gfx_context_t *gc;
668 gfx_bitmap_params_t params;
669 gfx_bitmap_t *bitmap;
670 async_sess_t *sess;
671 ipc_gc_t *ipcgc;
672
673 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
674
675 // FIXME This causes this test to be non-reentrant!
676 rc = loc_server_register(test_ipcgfx_server);
677 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
678
679 rc = loc_service_register(test_ipcgfx_svc, &sid);
680 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
681
682 sess = loc_service_connect(sid, INTERFACE_GC, 0);
683 PCUT_ASSERT_NOT_NULL(sess);
684
685 rc = ipc_gc_create(sess, &ipcgc);
686 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
687
688 gc = ipc_gc_get_ctx(ipcgc);
689 PCUT_ASSERT_NOT_NULL(gc);
690
691 resp.rc = EOK;
[a8eed5f]692 gfx_bitmap_params_init(&params);
[38e4f42]693 params.rect.p0.x = 1;
694 params.rect.p0.y = 2;
695 params.rect.p1.x = 3;
696 params.rect.p1.y = 4;
697 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
698 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
699 PCUT_ASSERT_NOT_NULL(bitmap);
700
701 resp.rc = EIO;
702 resp.bitmap_destroy_called = false;
703 rc = gfx_bitmap_destroy(bitmap);
704 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
705 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
706
707 ipc_gc_delete(ipcgc);
708 async_hangup(sess);
709
710 rc = loc_service_unregister(sid);
711 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
712}
713
[afcf704]714/** gfx_bitmap_create direct output bitmap with server returning failure */
715PCUT_TEST(bitmap_create_dout_failure)
716{
717 errno_t rc;
718 service_id_t sid;
719 test_response_t resp;
720 gfx_context_t *gc;
721 gfx_bitmap_params_t params;
722 gfx_bitmap_t *bitmap;
723 async_sess_t *sess;
724 ipc_gc_t *ipcgc;
725
726 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
727
728 // FIXME This causes this test to be non-reentrant!
729 rc = loc_server_register(test_ipcgfx_server);
730 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
731
732 rc = loc_service_register(test_ipcgfx_svc, &sid);
733 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
734
735 sess = loc_service_connect(sid, INTERFACE_GC, 0);
736 PCUT_ASSERT_NOT_NULL(sess);
737
738 rc = ipc_gc_create(sess, &ipcgc);
739 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
740
741 gc = ipc_gc_get_ctx(ipcgc);
742 PCUT_ASSERT_NOT_NULL(gc);
743
744 resp.rc = ENOMEM;
745 resp.bitmap_create_called = false;
746
747 gfx_bitmap_params_init(&params);
748 params.flags = bmpf_direct_output;
749 params.rect.p0.x = 1;
750 params.rect.p0.y = 2;
751 params.rect.p1.x = 3;
752 params.rect.p1.y = 4;
753 bitmap = NULL;
754 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
755 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
756 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
757 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
758 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
759 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
760 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
761 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
762 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
763 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
764 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
765 PCUT_ASSERT_NULL(bitmap);
766
767 ipc_gc_delete(ipcgc);
768 async_hangup(sess);
769
770 rc = loc_service_unregister(sid);
771 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
772}
773
774/** gfx_bitmap_create direct output bitmap with server returning success */
775PCUT_TEST(bitmap_create_dout_success)
776{
777 errno_t rc;
778 service_id_t sid;
779 test_response_t resp;
780 gfx_context_t *gc;
781 gfx_bitmap_params_t params;
782 gfx_bitmap_t *bitmap;
783 async_sess_t *sess;
784 ipc_gc_t *ipcgc;
785
786 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
787
788 // FIXME This causes this test to be non-reentrant!
789 rc = loc_server_register(test_ipcgfx_server);
790 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
791
792 rc = loc_service_register(test_ipcgfx_svc, &sid);
793 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
794
795 sess = loc_service_connect(sid, INTERFACE_GC, 0);
796 PCUT_ASSERT_NOT_NULL(sess);
797
798 rc = ipc_gc_create(sess, &ipcgc);
799 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
800
801 gc = ipc_gc_get_ctx(ipcgc);
802 PCUT_ASSERT_NOT_NULL(gc);
803
804 resp.rc = EOK;
805 resp.bitmap_create_called = false;
806
807 gfx_bitmap_params_init(&params);
808 params.flags = bmpf_direct_output;
809 params.rect.p0.x = 1;
810 params.rect.p0.y = 2;
811 params.rect.p1.x = 3;
812 params.rect.p1.y = 4;
813 bitmap = NULL;
814 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
815 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
816 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
817 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
818 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
819 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
820 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
821 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
822 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
823 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
824 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
825 PCUT_ASSERT_NOT_NULL(bitmap);
826
827 resp.bitmap_destroy_called = false;
828 rc = gfx_bitmap_destroy(bitmap);
829 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
830 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
831
832 ipc_gc_delete(ipcgc);
833 async_hangup(sess);
834
835 rc = loc_service_unregister(sid);
836 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
837}
838
[38e4f42]839/** gfx_bitmap_render with server returning failure */
840PCUT_TEST(bitmap_render_failure)
841{
842 errno_t rc;
843 service_id_t sid;
844 test_response_t resp;
845 gfx_context_t *gc;
846 gfx_bitmap_params_t params;
847 gfx_bitmap_t *bitmap;
848 gfx_rect_t srect;
849 gfx_coord2_t offs;
850 async_sess_t *sess;
851 ipc_gc_t *ipcgc;
852
853 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
854
855 // FIXME This causes this test to be non-reentrant!
856 rc = loc_server_register(test_ipcgfx_server);
857 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
858
859 rc = loc_service_register(test_ipcgfx_svc, &sid);
860 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
861
862 sess = loc_service_connect(sid, INTERFACE_GC, 0);
863 PCUT_ASSERT_NOT_NULL(sess);
864
865 rc = ipc_gc_create(sess, &ipcgc);
866 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
867
868 gc = ipc_gc_get_ctx(ipcgc);
869 PCUT_ASSERT_NOT_NULL(gc);
870
871 resp.rc = EOK;
[a8eed5f]872 gfx_bitmap_params_init(&params);
[38e4f42]873 params.rect.p0.x = 1;
874 params.rect.p0.y = 2;
875 params.rect.p1.x = 3;
876 params.rect.p1.y = 4;
877 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
878 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
879 PCUT_ASSERT_NOT_NULL(bitmap);
880
881 resp.rc = EIO;
882 srect.p0.x = 1;
883 srect.p0.y = 2;
884 srect.p1.x = 3;
885 srect.p1.y = 4;
886 rc = gfx_bitmap_render(bitmap, &srect, &offs);
887 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
888 PCUT_ASSERT_TRUE(resp.bitmap_render_called);
889 PCUT_ASSERT_EQUALS(srect.p0.x, resp.bitmap_render_srect.p0.x);
890 PCUT_ASSERT_EQUALS(srect.p0.y, resp.bitmap_render_srect.p0.y);
891 PCUT_ASSERT_EQUALS(srect.p1.x, resp.bitmap_render_srect.p1.x);
892 PCUT_ASSERT_EQUALS(srect.p1.y, resp.bitmap_render_srect.p1.y);
893 PCUT_ASSERT_EQUALS(offs.x, resp.bitmap_render_offs.x);
894 PCUT_ASSERT_EQUALS(offs.y, resp.bitmap_render_offs.y);
895
896 resp.rc = EOK;
897 rc = gfx_bitmap_destroy(bitmap);
898 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
899
900 ipc_gc_delete(ipcgc);
901 async_hangup(sess);
902
903 rc = loc_service_unregister(sid);
904 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
905}
906
907/** gfx_bitmap_render with server returning success */
908PCUT_TEST(bitmap_render_success)
909{
910 errno_t rc;
911 service_id_t sid;
912 test_response_t resp;
913 gfx_context_t *gc;
914 gfx_bitmap_params_t params;
915 gfx_bitmap_t *bitmap;
916 gfx_rect_t srect;
917 gfx_coord2_t offs;
918 async_sess_t *sess;
919 ipc_gc_t *ipcgc;
920
921 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
922
923 // FIXME This causes this test to be non-reentrant!
924 rc = loc_server_register(test_ipcgfx_server);
925 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
926
927 rc = loc_service_register(test_ipcgfx_svc, &sid);
928 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
929
930 sess = loc_service_connect(sid, INTERFACE_GC, 0);
931 PCUT_ASSERT_NOT_NULL(sess);
932
933 rc = ipc_gc_create(sess, &ipcgc);
934 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
935
936 gc = ipc_gc_get_ctx(ipcgc);
937 PCUT_ASSERT_NOT_NULL(gc);
938
939 resp.rc = EOK;
[a8eed5f]940 gfx_bitmap_params_init(&params);
[38e4f42]941 params.rect.p0.x = 1;
942 params.rect.p0.y = 2;
943 params.rect.p1.x = 3;
944 params.rect.p1.y = 4;
945 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
946 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
947 PCUT_ASSERT_NOT_NULL(bitmap);
948
949 resp.rc = EOK;
950 srect.p0.x = 1;
951 srect.p0.y = 2;
952 srect.p1.x = 3;
953 srect.p1.y = 4;
954 rc = gfx_bitmap_render(bitmap, &srect, &offs);
955 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
956 PCUT_ASSERT_TRUE(resp.bitmap_render_called);
957 PCUT_ASSERT_EQUALS(srect.p0.x, resp.bitmap_render_srect.p0.x);
958 PCUT_ASSERT_EQUALS(srect.p0.y, resp.bitmap_render_srect.p0.y);
959 PCUT_ASSERT_EQUALS(srect.p1.x, resp.bitmap_render_srect.p1.x);
960 PCUT_ASSERT_EQUALS(srect.p1.y, resp.bitmap_render_srect.p1.y);
961 PCUT_ASSERT_EQUALS(offs.x, resp.bitmap_render_offs.x);
962 PCUT_ASSERT_EQUALS(offs.y, resp.bitmap_render_offs.y);
963
964 resp.rc = EOK;
965 rc = gfx_bitmap_destroy(bitmap);
966 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
967
968 ipc_gc_delete(ipcgc);
969 async_hangup(sess);
970
971 rc = loc_service_unregister(sid);
972 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
973}
974
975/** gfx_bitmap_get_alloc - server is not currently involved */
976PCUT_TEST(bitmap_get_alloc)
977{
978 errno_t rc;
979 service_id_t sid;
980 test_response_t resp;
981 gfx_context_t *gc;
982 gfx_bitmap_params_t params;
983 gfx_bitmap_t *bitmap;
984 gfx_bitmap_alloc_t alloc;
985 async_sess_t *sess;
986 ipc_gc_t *ipcgc;
987
988 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
989
990 // FIXME This causes this test to be non-reentrant!
991 rc = loc_server_register(test_ipcgfx_server);
992 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
993
994 rc = loc_service_register(test_ipcgfx_svc, &sid);
995 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
996
997 sess = loc_service_connect(sid, INTERFACE_GC, 0);
998 PCUT_ASSERT_NOT_NULL(sess);
999
1000 rc = ipc_gc_create(sess, &ipcgc);
1001 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1002
1003 gc = ipc_gc_get_ctx(ipcgc);
1004 PCUT_ASSERT_NOT_NULL(gc);
1005
1006 resp.rc = EOK;
[a8eed5f]1007 gfx_bitmap_params_init(&params);
[38e4f42]1008 params.rect.p0.x = 1;
1009 params.rect.p0.y = 2;
1010 params.rect.p1.x = 3;
1011 params.rect.p1.y = 4;
1012 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
1013 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1014 PCUT_ASSERT_NOT_NULL(bitmap);
1015
1016 rc = gfx_bitmap_get_alloc(bitmap, &alloc);
1017 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1018
1019 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
1020 sizeof(uint32_t), (unsigned) alloc.pitch);
1021 PCUT_ASSERT_EQUALS(0, alloc.off0);
1022 PCUT_ASSERT_NOT_NULL(alloc.pixels);
1023
1024 resp.rc = EOK;
1025 rc = gfx_bitmap_destroy(bitmap);
1026 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1027
1028 ipc_gc_delete(ipcgc);
1029 async_hangup(sess);
1030
1031 rc = loc_service_unregister(sid);
1032 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
1033}
1034
1035static void test_ipcgc_conn(ipc_call_t *icall, void *arg)
1036{
1037 gfx_context_t *gc;
1038 errno_t rc;
1039
1040 rc = gfx_context_new(&test_gc_ops, arg, &gc);
1041 if (rc != EOK) {
1042 async_answer_0(icall, ENOMEM);
1043 return;
1044 }
1045
1046 /* Window GC connection */
1047 gc_conn(icall, gc);
1048}
1049
[7470d97]1050/** Set clipping rectangle in test GC.
1051 *
1052 * @param arg Test GC
1053 * @param rect Rectangle
1054 *
1055 * @return EOK on success or an error code
1056 */
1057static errno_t test_gc_set_clip_rect(void *arg, gfx_rect_t *rect)
1058{
1059 test_response_t *resp = (test_response_t *) arg;
1060
1061 resp->set_clip_rect_called = true;
1062 if (rect != NULL) {
1063 resp->do_clip = true;
1064 resp->set_clip_rect_rect = *rect;
1065 } else {
1066 resp->do_clip = false;
1067 }
1068
1069 return resp->rc;
1070}
1071
[38e4f42]1072/** Set color in test GC.
1073 *
1074 * Set drawing color in test GC.
1075 *
1076 * @param arg Test GC
1077 * @param color Color
1078 *
1079 * @return EOK on success or an error code
1080 */
1081static errno_t test_gc_set_color(void *arg, gfx_color_t *color)
1082{
1083 test_response_t *resp = (test_response_t *) arg;
1084
1085 resp->set_color_called = true;
1086 gfx_color_get_rgb_i16(color, &resp->set_color_r, &resp->set_color_g,
1087 &resp->set_color_b);
1088 return resp->rc;
1089}
1090
1091/** Fill rectangle in test GC.
1092 *
1093 * @param arg Test GC
1094 * @param rect Rectangle
1095 *
1096 * @return EOK on success or an error code
1097 */
1098static errno_t test_gc_fill_rect(void *arg, gfx_rect_t *rect)
1099{
1100 test_response_t *resp = (test_response_t *) arg;
1101
1102 resp->fill_rect_called = true;
1103 resp->fill_rect_rect = *rect;
1104 return resp->rc;
1105}
1106
[2ab8ab3]1107/** Update test GC.
1108 *
1109 * @param arg Test GC
1110 *
1111 * @return EOK on success or an error code
1112 */
1113static errno_t test_gc_update(void *arg)
1114{
1115 test_response_t *resp = (test_response_t *) arg;
1116
1117 resp->update_called = true;
1118 return resp->rc;
1119}
1120
[38e4f42]1121/** Create bitmap in test GC.
1122 *
1123 * @param arg Test GC
1124 * @param params Bitmap params
1125 * @param alloc Bitmap allocation info or @c NULL
1126 * @param rbm Place to store pointer to new bitmap
1127 * @return EOK on success or an error code
1128 */
1129errno_t test_gc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
1130 gfx_bitmap_alloc_t *alloc, void **rbm)
1131{
1132 test_response_t *resp = (test_response_t *) arg;
1133 test_bitmap_t *bitmap;
[afcf704]1134 gfx_coord2_t dim;
[38e4f42]1135
1136 resp->bitmap_create_called = true;
1137 resp->bitmap_create_params = *params;
[afcf704]1138
1139 if ((params->flags & bmpf_direct_output) != 0) {
1140 gfx_coord2_subtract(&params->rect.p1, &params->rect.p0, &dim);
1141
1142 resp->bitmap_create_alloc.pitch = dim.x * sizeof(uint32_t);
1143 resp->bitmap_create_alloc.off0 = 0;
1144 resp->bitmap_create_alloc.pixels = as_area_create(AS_AREA_ANY,
1145 dim.x * dim.y * sizeof(uint32_t), AS_AREA_READ |
1146 AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
1147 if (resp->bitmap_create_alloc.pixels == AS_MAP_FAILED)
1148 return ENOMEM;
1149 } else {
1150 resp->bitmap_create_alloc = *alloc;
1151 }
[38e4f42]1152
1153 if (resp->rc != EOK)
1154 return resp->rc;
1155
1156 bitmap = calloc(1, sizeof(test_bitmap_t));
1157 if (bitmap == NULL)
1158 return ENOMEM;
1159
1160 bitmap->resp = resp;
[afcf704]1161 bitmap->alloc = resp->bitmap_create_alloc;
[38e4f42]1162 *rbm = (void *) bitmap;
1163 return EOK;
1164}
1165
1166/** Destroy bitmap in test GC.
1167 *
1168 * @param bm Bitmap
1169 * @return EOK on success or an error code
1170 */
1171static errno_t test_gc_bitmap_destroy(void *bm)
1172{
1173 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
1174 test_response_t *resp = bitmap->resp;
1175
1176 resp->bitmap_destroy_called = true;
1177 if (resp->rc != EOK)
1178 return resp->rc;
1179
[afcf704]1180 if ((resp->bitmap_create_params.flags & bmpf_direct_output) != 0)
1181 as_area_destroy(resp->bitmap_create_alloc.pixels);
1182
[38e4f42]1183 free(bitmap);
1184 return EOK;
1185}
1186
1187/** Render bitmap in test GC.
1188 *
1189 * @param bm Bitmap
1190 * @param srect0 Source rectangle or @c NULL
1191 * @param offs0 Offset or @c NULL
1192 * @return EOK on success or an error code
1193 */
1194static errno_t test_gc_bitmap_render(void *bm, gfx_rect_t *srect0,
1195 gfx_coord2_t *offs0)
1196{
1197 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
1198 test_response_t *resp = bitmap->resp;
1199
1200 resp->bitmap_render_called = true;
1201 resp->bitmap_render_srect = *srect0;
1202 resp->bitmap_render_offs = *offs0;
1203 return resp->rc;
1204}
1205
1206/** Get allocation info for bitmap in test GC.
1207 *
1208 * @param bm Bitmap
1209 * @param alloc Place to store allocation info
1210 * @return EOK on success or an error code
1211 */
1212static errno_t test_gc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
1213{
[afcf704]1214 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
1215
1216 *alloc = bitmap->alloc;
1217 return EOK;
[38e4f42]1218}
1219
1220PCUT_EXPORT(ipcgfx);
Note: See TracBrowser for help on using the repository browser.