source: mainline/uspace/lib/ipcgfx/test/ipcgfx.c@ 8bf9058

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 8bf9058 was afcf704, checked in by Jiri Svoboda <jiri@…>, 5 years ago

Allow GUI direct access to window buffer
  • Property mode set to 100644
File size: 25.2 KB
Line 
1/*
2 * Copyright (c) 2019 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_color(void *, gfx_color_t *);
53static errno_t test_gc_fill_rect(void *, gfx_rect_t *);
54static errno_t test_gc_bitmap_create(void *, gfx_bitmap_params_t *,
55 gfx_bitmap_alloc_t *, void **);
56static errno_t test_gc_bitmap_destroy(void *);
57static errno_t test_gc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
58static errno_t test_gc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
59
60static gfx_context_ops_t test_gc_ops = {
61 .set_color = test_gc_set_color,
62 .fill_rect = test_gc_fill_rect,
63 .bitmap_create = test_gc_bitmap_create,
64 .bitmap_destroy = test_gc_bitmap_destroy,
65 .bitmap_render = test_gc_bitmap_render,
66 .bitmap_get_alloc = test_gc_bitmap_get_alloc
67};
68
69/** Describes to the server how to respond to our request and pass tracking
70 * data back to the client.
71 */
72typedef struct {
73 errno_t rc;
74
75 bool set_color_called;
76 uint16_t set_color_r;
77 uint16_t set_color_g;
78 uint16_t set_color_b;
79
80 bool fill_rect_called;
81 gfx_rect_t fill_rect_rect;
82
83 bool bitmap_create_called;
84 gfx_bitmap_params_t bitmap_create_params;
85 gfx_bitmap_alloc_t bitmap_create_alloc;
86
87 bool bitmap_destroy_called;
88
89 bool bitmap_render_called;
90 gfx_rect_t bitmap_render_srect;
91 gfx_coord2_t bitmap_render_offs;
92
93 bool bitmap_get_alloc_called;
94} test_response_t;
95
96/** Bitmap in test GC */
97typedef struct {
98 test_response_t *resp;
99 gfx_bitmap_alloc_t alloc;
100} test_bitmap_t;
101
102/** gfx_set_color with server returning failure */
103PCUT_TEST(set_color_failure)
104{
105 errno_t rc;
106 service_id_t sid;
107 test_response_t resp;
108 gfx_context_t *gc;
109 gfx_color_t *color;
110 async_sess_t *sess;
111 ipc_gc_t *ipcgc;
112
113 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
114
115 // FIXME This causes this test to be non-reentrant!
116 rc = loc_server_register(test_ipcgfx_server);
117 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
118
119 rc = loc_service_register(test_ipcgfx_svc, &sid);
120 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
121
122 sess = loc_service_connect(sid, INTERFACE_GC, 0);
123 PCUT_ASSERT_NOT_NULL(sess);
124
125 rc = ipc_gc_create(sess, &ipcgc);
126 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
127
128 gc = ipc_gc_get_ctx(ipcgc);
129 PCUT_ASSERT_NOT_NULL(gc);
130
131 rc = gfx_color_new_rgb_i16(1, 2, 3, &color);
132 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
133
134 resp.rc = ENOMEM;
135 resp.set_color_called = false;
136 rc = gfx_set_color(gc, color);
137 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
138 PCUT_ASSERT_TRUE(resp.set_color_called);
139 PCUT_ASSERT_EQUALS(1, resp.set_color_r);
140 PCUT_ASSERT_EQUALS(2, resp.set_color_g);
141 PCUT_ASSERT_EQUALS(3, resp.set_color_b);
142
143 gfx_color_delete(color);
144
145 ipc_gc_delete(ipcgc);
146 async_hangup(sess);
147
148 rc = loc_service_unregister(sid);
149 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
150}
151
152/** gfx_set_color with server returning success */
153PCUT_TEST(set_color_success)
154{
155 errno_t rc;
156 service_id_t sid;
157 test_response_t resp;
158 gfx_context_t *gc;
159 gfx_color_t *color;
160 async_sess_t *sess;
161 ipc_gc_t *ipcgc;
162
163 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
164
165 // FIXME This causes this test to be non-reentrant!
166 rc = loc_server_register(test_ipcgfx_server);
167 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
168
169 rc = loc_service_register(test_ipcgfx_svc, &sid);
170 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
171
172 sess = loc_service_connect(sid, INTERFACE_GC, 0);
173 PCUT_ASSERT_NOT_NULL(sess);
174
175 rc = ipc_gc_create(sess, &ipcgc);
176 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
177
178 gc = ipc_gc_get_ctx(ipcgc);
179 PCUT_ASSERT_NOT_NULL(gc);
180
181 rc = gfx_color_new_rgb_i16(1, 2, 3, &color);
182 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
183
184 resp.rc = EOK;
185 resp.set_color_called = false;
186 rc = gfx_set_color(gc, color);
187 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
188 PCUT_ASSERT_TRUE(resp.set_color_called);
189 PCUT_ASSERT_EQUALS(1, resp.set_color_r);
190 PCUT_ASSERT_EQUALS(2, resp.set_color_g);
191 PCUT_ASSERT_EQUALS(3, resp.set_color_b);
192
193 gfx_color_delete(color);
194
195 ipc_gc_delete(ipcgc);
196 async_hangup(sess);
197
198 rc = loc_service_unregister(sid);
199 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
200}
201
202/** gfx_fill_rect with server returning failure */
203PCUT_TEST(fill_rect_failure)
204{
205 errno_t rc;
206 service_id_t sid;
207 test_response_t resp;
208 gfx_context_t *gc;
209 gfx_rect_t rect;
210 async_sess_t *sess;
211 ipc_gc_t *ipcgc;
212
213 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
214
215 // FIXME This causes this test to be non-reentrant!
216 rc = loc_server_register(test_ipcgfx_server);
217 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
218
219 rc = loc_service_register(test_ipcgfx_svc, &sid);
220 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
221
222 sess = loc_service_connect(sid, INTERFACE_GC, 0);
223 PCUT_ASSERT_NOT_NULL(sess);
224
225 rc = ipc_gc_create(sess, &ipcgc);
226 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
227
228 gc = ipc_gc_get_ctx(ipcgc);
229 PCUT_ASSERT_NOT_NULL(gc);
230
231 resp.rc = ENOMEM;
232 resp.set_color_called = false;
233 rect.p0.x = 1;
234 rect.p0.y = 2;
235 rect.p1.x = 3;
236 rect.p1.y = 4;
237 rc = gfx_fill_rect(gc, &rect);
238 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
239 PCUT_ASSERT_TRUE(resp.fill_rect_called);
240 PCUT_ASSERT_EQUALS(rect.p0.x, resp.fill_rect_rect.p0.x);
241 PCUT_ASSERT_EQUALS(rect.p0.y, resp.fill_rect_rect.p0.y);
242 PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
243 PCUT_ASSERT_EQUALS(rect.p1.y, resp.fill_rect_rect.p1.y);
244
245 ipc_gc_delete(ipcgc);
246 async_hangup(sess);
247
248 rc = loc_service_unregister(sid);
249 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
250}
251
252/** gfx_fill_rect with server returning success */
253PCUT_TEST(fill_rect_success)
254{
255 errno_t rc;
256 service_id_t sid;
257 test_response_t resp;
258 gfx_context_t *gc;
259 gfx_rect_t rect;
260 async_sess_t *sess;
261 ipc_gc_t *ipcgc;
262
263 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
264
265 // FIXME This causes this test to be non-reentrant!
266 rc = loc_server_register(test_ipcgfx_server);
267 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
268
269 rc = loc_service_register(test_ipcgfx_svc, &sid);
270 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
271
272 sess = loc_service_connect(sid, INTERFACE_GC, 0);
273 PCUT_ASSERT_NOT_NULL(sess);
274
275 rc = ipc_gc_create(sess, &ipcgc);
276 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
277
278 gc = ipc_gc_get_ctx(ipcgc);
279 PCUT_ASSERT_NOT_NULL(gc);
280
281 resp.rc = EOK;
282 resp.set_color_called = false;
283 rect.p0.x = 1;
284 rect.p0.y = 2;
285 rect.p1.x = 3;
286 rect.p1.y = 4;
287 rc = gfx_fill_rect(gc, &rect);
288 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
289 PCUT_ASSERT_TRUE(resp.fill_rect_called);
290 PCUT_ASSERT_EQUALS(rect.p0.x, resp.fill_rect_rect.p0.x);
291 PCUT_ASSERT_EQUALS(rect.p0.y, resp.fill_rect_rect.p0.y);
292 PCUT_ASSERT_EQUALS(rect.p1.x, resp.fill_rect_rect.p1.x);
293 PCUT_ASSERT_EQUALS(rect.p1.y, resp.fill_rect_rect.p1.y);
294
295 ipc_gc_delete(ipcgc);
296 async_hangup(sess);
297
298 rc = loc_service_unregister(sid);
299 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
300}
301
302/** gfx_bitmap_create with server returning failure */
303PCUT_TEST(bitmap_create_failure)
304{
305 errno_t rc;
306 service_id_t sid;
307 test_response_t resp;
308 gfx_context_t *gc;
309 gfx_bitmap_params_t params;
310 gfx_bitmap_t *bitmap;
311 async_sess_t *sess;
312 ipc_gc_t *ipcgc;
313
314 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
315
316 // FIXME This causes this test to be non-reentrant!
317 rc = loc_server_register(test_ipcgfx_server);
318 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
319
320 rc = loc_service_register(test_ipcgfx_svc, &sid);
321 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
322
323 sess = loc_service_connect(sid, INTERFACE_GC, 0);
324 PCUT_ASSERT_NOT_NULL(sess);
325
326 rc = ipc_gc_create(sess, &ipcgc);
327 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
328
329 gc = ipc_gc_get_ctx(ipcgc);
330 PCUT_ASSERT_NOT_NULL(gc);
331
332 resp.rc = ENOMEM;
333 resp.bitmap_create_called = false;
334
335 gfx_bitmap_params_init(&params);
336 params.rect.p0.x = 1;
337 params.rect.p0.y = 2;
338 params.rect.p1.x = 3;
339 params.rect.p1.y = 4;
340 bitmap = NULL;
341 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
342 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
343 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
344 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
345 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
346 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
347 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
348 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
349 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
350 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
351 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
352 PCUT_ASSERT_NULL(bitmap);
353
354 ipc_gc_delete(ipcgc);
355 async_hangup(sess);
356
357 rc = loc_service_unregister(sid);
358 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
359}
360
361/** gfx_bitmap_create and gfx_bitmap_destroy with server returning success */
362PCUT_TEST(bitmap_create_destroy_success)
363{
364 errno_t rc;
365 service_id_t sid;
366 test_response_t resp;
367 gfx_context_t *gc;
368 gfx_bitmap_params_t params;
369 gfx_bitmap_t *bitmap;
370 async_sess_t *sess;
371 ipc_gc_t *ipcgc;
372
373 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
374
375 // FIXME This causes this test to be non-reentrant!
376 rc = loc_server_register(test_ipcgfx_server);
377 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
378
379 rc = loc_service_register(test_ipcgfx_svc, &sid);
380 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
381
382 sess = loc_service_connect(sid, INTERFACE_GC, 0);
383 PCUT_ASSERT_NOT_NULL(sess);
384
385 rc = ipc_gc_create(sess, &ipcgc);
386 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
387
388 gc = ipc_gc_get_ctx(ipcgc);
389 PCUT_ASSERT_NOT_NULL(gc);
390
391 resp.rc = EOK;
392 resp.bitmap_create_called = false;
393
394 gfx_bitmap_params_init(&params);
395 params.rect.p0.x = 1;
396 params.rect.p0.y = 2;
397 params.rect.p1.x = 3;
398 params.rect.p1.y = 4;
399 bitmap = NULL;
400 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
401 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
402 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
403 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
404 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
405 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
406 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
407 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
408 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
409 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
410 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
411 PCUT_ASSERT_NOT_NULL(bitmap);
412
413 resp.bitmap_destroy_called = false;
414 rc = gfx_bitmap_destroy(bitmap);
415 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
416 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
417
418 ipc_gc_delete(ipcgc);
419 async_hangup(sess);
420
421 rc = loc_service_unregister(sid);
422 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
423}
424
425/** gfx_bitmap_destroy with server returning failure */
426PCUT_TEST(bitmap_destroy_failure)
427{
428 errno_t rc;
429 service_id_t sid;
430 test_response_t resp;
431 gfx_context_t *gc;
432 gfx_bitmap_params_t params;
433 gfx_bitmap_t *bitmap;
434 async_sess_t *sess;
435 ipc_gc_t *ipcgc;
436
437 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
438
439 // FIXME This causes this test to be non-reentrant!
440 rc = loc_server_register(test_ipcgfx_server);
441 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
442
443 rc = loc_service_register(test_ipcgfx_svc, &sid);
444 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
445
446 sess = loc_service_connect(sid, INTERFACE_GC, 0);
447 PCUT_ASSERT_NOT_NULL(sess);
448
449 rc = ipc_gc_create(sess, &ipcgc);
450 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
451
452 gc = ipc_gc_get_ctx(ipcgc);
453 PCUT_ASSERT_NOT_NULL(gc);
454
455 resp.rc = EOK;
456 gfx_bitmap_params_init(&params);
457 params.rect.p0.x = 1;
458 params.rect.p0.y = 2;
459 params.rect.p1.x = 3;
460 params.rect.p1.y = 4;
461 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
462 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
463 PCUT_ASSERT_NOT_NULL(bitmap);
464
465 resp.rc = EIO;
466 resp.bitmap_destroy_called = false;
467 rc = gfx_bitmap_destroy(bitmap);
468 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
469 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
470
471 ipc_gc_delete(ipcgc);
472 async_hangup(sess);
473
474 rc = loc_service_unregister(sid);
475 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
476}
477
478/** gfx_bitmap_create direct output bitmap with server returning failure */
479PCUT_TEST(bitmap_create_dout_failure)
480{
481 errno_t rc;
482 service_id_t sid;
483 test_response_t resp;
484 gfx_context_t *gc;
485 gfx_bitmap_params_t params;
486 gfx_bitmap_t *bitmap;
487 async_sess_t *sess;
488 ipc_gc_t *ipcgc;
489
490 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
491
492 // FIXME This causes this test to be non-reentrant!
493 rc = loc_server_register(test_ipcgfx_server);
494 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
495
496 rc = loc_service_register(test_ipcgfx_svc, &sid);
497 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
498
499 sess = loc_service_connect(sid, INTERFACE_GC, 0);
500 PCUT_ASSERT_NOT_NULL(sess);
501
502 rc = ipc_gc_create(sess, &ipcgc);
503 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
504
505 gc = ipc_gc_get_ctx(ipcgc);
506 PCUT_ASSERT_NOT_NULL(gc);
507
508 resp.rc = ENOMEM;
509 resp.bitmap_create_called = false;
510
511 gfx_bitmap_params_init(&params);
512 params.flags = bmpf_direct_output;
513 params.rect.p0.x = 1;
514 params.rect.p0.y = 2;
515 params.rect.p1.x = 3;
516 params.rect.p1.y = 4;
517 bitmap = NULL;
518 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
519 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
520 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
521 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
522 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
523 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
524 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
525 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
526 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
527 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
528 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
529 PCUT_ASSERT_NULL(bitmap);
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
538/** gfx_bitmap_create direct output bitmap with server returning success */
539PCUT_TEST(bitmap_create_dout_success)
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 = EOK;
569 resp.bitmap_create_called = false;
570
571 gfx_bitmap_params_init(&params);
572 params.flags = bmpf_direct_output;
573 params.rect.p0.x = 1;
574 params.rect.p0.y = 2;
575 params.rect.p1.x = 3;
576 params.rect.p1.y = 4;
577 bitmap = NULL;
578 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
579 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
580 PCUT_ASSERT_TRUE(resp.bitmap_create_called);
581 PCUT_ASSERT_EQUALS(params.rect.p0.x, resp.bitmap_create_params.rect.p0.x);
582 PCUT_ASSERT_EQUALS(params.rect.p0.y, resp.bitmap_create_params.rect.p0.y);
583 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.bitmap_create_params.rect.p1.x);
584 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.bitmap_create_params.rect.p1.y);
585 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
586 sizeof(uint32_t), (unsigned) resp.bitmap_create_alloc.pitch);
587 PCUT_ASSERT_EQUALS(0, resp.bitmap_create_alloc.off0);
588 PCUT_ASSERT_NOT_NULL(resp.bitmap_create_alloc.pixels);
589 PCUT_ASSERT_NOT_NULL(bitmap);
590
591 resp.bitmap_destroy_called = false;
592 rc = gfx_bitmap_destroy(bitmap);
593 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
594 PCUT_ASSERT_TRUE(resp.bitmap_destroy_called);
595
596 ipc_gc_delete(ipcgc);
597 async_hangup(sess);
598
599 rc = loc_service_unregister(sid);
600 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
601}
602
603/** gfx_bitmap_render with server returning failure */
604PCUT_TEST(bitmap_render_failure)
605{
606 errno_t rc;
607 service_id_t sid;
608 test_response_t resp;
609 gfx_context_t *gc;
610 gfx_bitmap_params_t params;
611 gfx_bitmap_t *bitmap;
612 gfx_rect_t srect;
613 gfx_coord2_t offs;
614 async_sess_t *sess;
615 ipc_gc_t *ipcgc;
616
617 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
618
619 // FIXME This causes this test to be non-reentrant!
620 rc = loc_server_register(test_ipcgfx_server);
621 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
622
623 rc = loc_service_register(test_ipcgfx_svc, &sid);
624 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
625
626 sess = loc_service_connect(sid, INTERFACE_GC, 0);
627 PCUT_ASSERT_NOT_NULL(sess);
628
629 rc = ipc_gc_create(sess, &ipcgc);
630 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
631
632 gc = ipc_gc_get_ctx(ipcgc);
633 PCUT_ASSERT_NOT_NULL(gc);
634
635 resp.rc = EOK;
636 gfx_bitmap_params_init(&params);
637 params.rect.p0.x = 1;
638 params.rect.p0.y = 2;
639 params.rect.p1.x = 3;
640 params.rect.p1.y = 4;
641 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
642 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
643 PCUT_ASSERT_NOT_NULL(bitmap);
644
645 resp.rc = EIO;
646 srect.p0.x = 1;
647 srect.p0.y = 2;
648 srect.p1.x = 3;
649 srect.p1.y = 4;
650 rc = gfx_bitmap_render(bitmap, &srect, &offs);
651 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
652 PCUT_ASSERT_TRUE(resp.bitmap_render_called);
653 PCUT_ASSERT_EQUALS(srect.p0.x, resp.bitmap_render_srect.p0.x);
654 PCUT_ASSERT_EQUALS(srect.p0.y, resp.bitmap_render_srect.p0.y);
655 PCUT_ASSERT_EQUALS(srect.p1.x, resp.bitmap_render_srect.p1.x);
656 PCUT_ASSERT_EQUALS(srect.p1.y, resp.bitmap_render_srect.p1.y);
657 PCUT_ASSERT_EQUALS(offs.x, resp.bitmap_render_offs.x);
658 PCUT_ASSERT_EQUALS(offs.y, resp.bitmap_render_offs.y);
659
660 resp.rc = EOK;
661 rc = gfx_bitmap_destroy(bitmap);
662 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
663
664 ipc_gc_delete(ipcgc);
665 async_hangup(sess);
666
667 rc = loc_service_unregister(sid);
668 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
669}
670
671/** gfx_bitmap_render with server returning success */
672PCUT_TEST(bitmap_render_success)
673{
674 errno_t rc;
675 service_id_t sid;
676 test_response_t resp;
677 gfx_context_t *gc;
678 gfx_bitmap_params_t params;
679 gfx_bitmap_t *bitmap;
680 gfx_rect_t srect;
681 gfx_coord2_t offs;
682 async_sess_t *sess;
683 ipc_gc_t *ipcgc;
684
685 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
686
687 // FIXME This causes this test to be non-reentrant!
688 rc = loc_server_register(test_ipcgfx_server);
689 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
690
691 rc = loc_service_register(test_ipcgfx_svc, &sid);
692 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
693
694 sess = loc_service_connect(sid, INTERFACE_GC, 0);
695 PCUT_ASSERT_NOT_NULL(sess);
696
697 rc = ipc_gc_create(sess, &ipcgc);
698 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
699
700 gc = ipc_gc_get_ctx(ipcgc);
701 PCUT_ASSERT_NOT_NULL(gc);
702
703 resp.rc = EOK;
704 gfx_bitmap_params_init(&params);
705 params.rect.p0.x = 1;
706 params.rect.p0.y = 2;
707 params.rect.p1.x = 3;
708 params.rect.p1.y = 4;
709 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
710 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
711 PCUT_ASSERT_NOT_NULL(bitmap);
712
713 resp.rc = EOK;
714 srect.p0.x = 1;
715 srect.p0.y = 2;
716 srect.p1.x = 3;
717 srect.p1.y = 4;
718 rc = gfx_bitmap_render(bitmap, &srect, &offs);
719 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
720 PCUT_ASSERT_TRUE(resp.bitmap_render_called);
721 PCUT_ASSERT_EQUALS(srect.p0.x, resp.bitmap_render_srect.p0.x);
722 PCUT_ASSERT_EQUALS(srect.p0.y, resp.bitmap_render_srect.p0.y);
723 PCUT_ASSERT_EQUALS(srect.p1.x, resp.bitmap_render_srect.p1.x);
724 PCUT_ASSERT_EQUALS(srect.p1.y, resp.bitmap_render_srect.p1.y);
725 PCUT_ASSERT_EQUALS(offs.x, resp.bitmap_render_offs.x);
726 PCUT_ASSERT_EQUALS(offs.y, resp.bitmap_render_offs.y);
727
728 resp.rc = EOK;
729 rc = gfx_bitmap_destroy(bitmap);
730 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
731
732 ipc_gc_delete(ipcgc);
733 async_hangup(sess);
734
735 rc = loc_service_unregister(sid);
736 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
737}
738
739/** gfx_bitmap_get_alloc - server is not currently involved */
740PCUT_TEST(bitmap_get_alloc)
741{
742 errno_t rc;
743 service_id_t sid;
744 test_response_t resp;
745 gfx_context_t *gc;
746 gfx_bitmap_params_t params;
747 gfx_bitmap_t *bitmap;
748 gfx_bitmap_alloc_t alloc;
749 async_sess_t *sess;
750 ipc_gc_t *ipcgc;
751
752 async_set_fallback_port_handler(test_ipcgc_conn, &resp);
753
754 // FIXME This causes this test to be non-reentrant!
755 rc = loc_server_register(test_ipcgfx_server);
756 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
757
758 rc = loc_service_register(test_ipcgfx_svc, &sid);
759 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
760
761 sess = loc_service_connect(sid, INTERFACE_GC, 0);
762 PCUT_ASSERT_NOT_NULL(sess);
763
764 rc = ipc_gc_create(sess, &ipcgc);
765 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
766
767 gc = ipc_gc_get_ctx(ipcgc);
768 PCUT_ASSERT_NOT_NULL(gc);
769
770 resp.rc = EOK;
771 gfx_bitmap_params_init(&params);
772 params.rect.p0.x = 1;
773 params.rect.p0.y = 2;
774 params.rect.p1.x = 3;
775 params.rect.p1.y = 4;
776 rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
777 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
778 PCUT_ASSERT_NOT_NULL(bitmap);
779
780 rc = gfx_bitmap_get_alloc(bitmap, &alloc);
781 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
782
783 PCUT_ASSERT_EQUALS((params.rect.p1.x - params.rect.p0.x) *
784 sizeof(uint32_t), (unsigned) alloc.pitch);
785 PCUT_ASSERT_EQUALS(0, alloc.off0);
786 PCUT_ASSERT_NOT_NULL(alloc.pixels);
787
788 resp.rc = EOK;
789 rc = gfx_bitmap_destroy(bitmap);
790 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
791
792 ipc_gc_delete(ipcgc);
793 async_hangup(sess);
794
795 rc = loc_service_unregister(sid);
796 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
797}
798
799static void test_ipcgc_conn(ipc_call_t *icall, void *arg)
800{
801 gfx_context_t *gc;
802 errno_t rc;
803
804 rc = gfx_context_new(&test_gc_ops, arg, &gc);
805 if (rc != EOK) {
806 async_answer_0(icall, ENOMEM);
807 return;
808 }
809
810 /* Window GC connection */
811 gc_conn(icall, gc);
812}
813
814/** Set color in test GC.
815 *
816 * Set drawing color in test GC.
817 *
818 * @param arg Test GC
819 * @param color Color
820 *
821 * @return EOK on success or an error code
822 */
823static errno_t test_gc_set_color(void *arg, gfx_color_t *color)
824{
825 test_response_t *resp = (test_response_t *) arg;
826
827 resp->set_color_called = true;
828 gfx_color_get_rgb_i16(color, &resp->set_color_r, &resp->set_color_g,
829 &resp->set_color_b);
830 return resp->rc;
831}
832
833/** Fill rectangle in test GC.
834 *
835 * @param arg Test GC
836 * @param rect Rectangle
837 *
838 * @return EOK on success or an error code
839 */
840static errno_t test_gc_fill_rect(void *arg, gfx_rect_t *rect)
841{
842 test_response_t *resp = (test_response_t *) arg;
843
844 resp->fill_rect_called = true;
845 resp->fill_rect_rect = *rect;
846 return resp->rc;
847}
848
849/** Create bitmap in test GC.
850 *
851 * @param arg Test GC
852 * @param params Bitmap params
853 * @param alloc Bitmap allocation info or @c NULL
854 * @param rbm Place to store pointer to new bitmap
855 * @return EOK on success or an error code
856 */
857errno_t test_gc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
858 gfx_bitmap_alloc_t *alloc, void **rbm)
859{
860 test_response_t *resp = (test_response_t *) arg;
861 test_bitmap_t *bitmap;
862 gfx_coord2_t dim;
863
864 resp->bitmap_create_called = true;
865 resp->bitmap_create_params = *params;
866
867 if ((params->flags & bmpf_direct_output) != 0) {
868 gfx_coord2_subtract(&params->rect.p1, &params->rect.p0, &dim);
869
870 resp->bitmap_create_alloc.pitch = dim.x * sizeof(uint32_t);
871 resp->bitmap_create_alloc.off0 = 0;
872 resp->bitmap_create_alloc.pixels = as_area_create(AS_AREA_ANY,
873 dim.x * dim.y * sizeof(uint32_t), AS_AREA_READ |
874 AS_AREA_WRITE | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
875 if (resp->bitmap_create_alloc.pixels == AS_MAP_FAILED)
876 return ENOMEM;
877 } else {
878 resp->bitmap_create_alloc = *alloc;
879 }
880
881 if (resp->rc != EOK)
882 return resp->rc;
883
884 bitmap = calloc(1, sizeof(test_bitmap_t));
885 if (bitmap == NULL)
886 return ENOMEM;
887
888 bitmap->resp = resp;
889 bitmap->alloc = resp->bitmap_create_alloc;
890 *rbm = (void *) bitmap;
891 return EOK;
892}
893
894/** Destroy bitmap in test GC.
895 *
896 * @param bm Bitmap
897 * @return EOK on success or an error code
898 */
899static errno_t test_gc_bitmap_destroy(void *bm)
900{
901 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
902 test_response_t *resp = bitmap->resp;
903
904 resp->bitmap_destroy_called = true;
905 if (resp->rc != EOK)
906 return resp->rc;
907
908 if ((resp->bitmap_create_params.flags & bmpf_direct_output) != 0)
909 as_area_destroy(resp->bitmap_create_alloc.pixels);
910
911 free(bitmap);
912 return EOK;
913}
914
915/** Render bitmap in test GC.
916 *
917 * @param bm Bitmap
918 * @param srect0 Source rectangle or @c NULL
919 * @param offs0 Offset or @c NULL
920 * @return EOK on success or an error code
921 */
922static errno_t test_gc_bitmap_render(void *bm, gfx_rect_t *srect0,
923 gfx_coord2_t *offs0)
924{
925 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
926 test_response_t *resp = bitmap->resp;
927
928 resp->bitmap_render_called = true;
929 resp->bitmap_render_srect = *srect0;
930 resp->bitmap_render_offs = *offs0;
931 return resp->rc;
932}
933
934/** Get allocation info for bitmap in test GC.
935 *
936 * @param bm Bitmap
937 * @param alloc Place to store allocation info
938 * @return EOK on success or an error code
939 */
940static errno_t test_gc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
941{
942 test_bitmap_t *bitmap = (test_bitmap_t *) bm;
943
944 *alloc = bitmap->alloc;
945 return EOK;
946}
947
948PCUT_EXPORT(ipcgfx);
Note: See TracBrowser for help on using the repository browser.