Context Navigation

ipcgfx.c@ 5d62130

Visit:

ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 5d62130 was 7470d97, checked in by Jiri Svoboda <jiri@…>, 4 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

Line
1	/*
2	* Copyright (c) 2021 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
43	PCUT_INIT;
44
45	PCUT_TEST_SUITE(ipcgfx);
46
47	static const char *test_ipcgfx_server = "test-ipcgfx";
48	static const char *test_ipcgfx_svc = "test/ipcgfx";
49
50	static void test_ipcgc_conn(ipc_call_t , void );
51
52	static errno_t test_gc_set_clip_rect(void , gfx_rect_t );
53	static errno_t test_gc_set_color(void , gfx_color_t );
54	static errno_t test_gc_fill_rect(void , gfx_rect_t );
55	static errno_t test_gc_update(void *);
56	static errno_t test_gc_bitmap_create(void , gfx_bitmap_params_t ,
57	gfx_bitmap_alloc_t , void *);
58	static errno_t test_gc_bitmap_destroy(void *);
59	static errno_t test_gc_bitmap_render(void , gfx_rect_t , gfx_coord2_t *);
60	static errno_t test_gc_bitmap_get_alloc(void , gfx_bitmap_alloc_t );
61
62	static 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	*/
76	typedef 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 */
107	typedef 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 */
113	PCUT_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 */
163	PCUT_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 */
214	PCUT_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
256	/** gfx_set_color with server returning failure */
257	PCUT_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 */
307	PCUT_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 */
357	PCUT_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;
386	resp.fill_rect_called = false;
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 */
407	PCUT_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;
436	resp.fill_rect_called = false;
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
456	/** gfx_update with server returning failure */
457	PCUT_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 */
498	PCUT_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
538	/** gfx_bitmap_create with server returning failure */
539	PCUT_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;
570
571	gfx_bitmap_params_init(&params);
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 */
598	PCUT_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;
629
630	gfx_bitmap_params_init(&params);
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 */
662	PCUT_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;
692	gfx_bitmap_params_init(&params);
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
714	/** gfx_bitmap_create direct output bitmap with server returning failure */
715	PCUT_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 */
775	PCUT_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
839	/** gfx_bitmap_render with server returning failure */
840	PCUT_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;
872	gfx_bitmap_params_init(&params);
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 */
908	PCUT_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;
940	gfx_bitmap_params_init(&params);
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 */
976	PCUT_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;
1007	gfx_bitmap_params_init(&params);
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
1035	static 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
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	*/
1057	static 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
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	*/
1081	static 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	*/
1098	static 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
1107	/** Update test GC.
1108	*
1109	* @param arg Test GC
1110	*
1111	* @return EOK on success or an error code
1112	*/
1113	static 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
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	*/
1129	errno_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;
1134	gfx_coord2_t dim;
1135
1136	resp->bitmap_create_called = true;
1137	resp->bitmap_create_params = *params;
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	}
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;
1161	bitmap->alloc = resp->bitmap_create_alloc;
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	*/
1171	static 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
1180	if ((resp->bitmap_create_params.flags & bmpf_direct_output) != 0)
1181	as_area_destroy(resp->bitmap_create_alloc.pixels);
1182
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	*/
1194	static 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	*/
1212	static errno_t test_gc_bitmap_get_alloc(void bm, gfx_bitmap_alloc_t alloc)
1213	{
1214	test_bitmap_t bitmap = (test_bitmap_t ) bm;
1215
1216	*alloc = bitmap->alloc;
1217	return EOK;
1218	}
1219
1220	PCUT_EXPORT(ipcgfx);

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: mainline/uspace/lib/ipcgfx/test/ipcgfx.c@ 5d62130

Download in other formats: