source: mainline/uspace/lib/ipcgfx/test/ipcgfx.c

Last change on this file was ca48672, checked in by Jiri Svoboda <jiri@…>, 8 days ago

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