source: mainline/uspace/lib/ddev/test/ddev.c@ b252e87

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

Add method for getting display device information
  • Property mode set to 100644
File size: 8.0 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 <async.h>
30#include <errno.h>
31#include <ddev.h>
32#include <ddev_srv.h>
33#include <fibril_synch.h>
34#include <gfx/color.h>
35#include <gfx/context.h>
36#include <gfx/render.h>
37#include <ipcgfx/server.h>
38#include <loc.h>
39#include <pcut/pcut.h>
40
41PCUT_INIT;
42
43PCUT_TEST_SUITE(ddev);
44
45static const char *test_ddev_server = "test-ddev";
46static const char *test_ddev_svc = "test/ddev";
47
48static void test_ddev_conn(ipc_call_t *, void *);
49
50static errno_t test_get_gc(void *, sysarg_t *, sysarg_t *);
51static errno_t test_get_info(void *, ddev_info_t *);
52static errno_t test_gc_set_color(void *, gfx_color_t *);
53
54static ddev_ops_t test_ddev_ops = {
55 .get_gc = test_get_gc,
56 .get_info = test_get_info
57};
58
59static gfx_context_ops_t test_gc_ops = {
60 .set_color = test_gc_set_color
61};
62
63/** Describes to the server how to respond to our request and pass tracking
64 * data back to the client.
65 */
66typedef struct {
67 errno_t rc;
68 bool set_color_called;
69 ddev_srv_t *srv;
70 ddev_info_t info;
71} test_response_t;
72
73/** ddev_open(), ddev_close() work for valid display device service */
74PCUT_TEST(open_close)
75{
76 errno_t rc;
77 service_id_t sid;
78 ddev_t *ddev = NULL;
79 test_response_t resp;
80
81 async_set_fallback_port_handler(test_ddev_conn, &resp);
82
83 // FIXME This causes this test to be non-reentrant!
84 rc = loc_server_register(test_ddev_server);
85 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
86
87 rc = loc_service_register(test_ddev_svc, &sid);
88 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
89
90 rc = ddev_open(test_ddev_svc, &ddev);
91 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
92 PCUT_ASSERT_NOT_NULL(ddev);
93
94 ddev_close(ddev);
95 rc = loc_service_unregister(sid);
96 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
97}
98
99/** ddev_get_gc with server returning failure */
100PCUT_TEST(dev_get_gc_failure)
101{
102 errno_t rc;
103 service_id_t sid;
104 ddev_t *ddev = NULL;
105 test_response_t resp;
106 gfx_context_t *gc;
107
108 async_set_fallback_port_handler(test_ddev_conn, &resp);
109
110 // FIXME This causes this test to be non-reentrant!
111 rc = loc_server_register(test_ddev_server);
112 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
113
114 rc = loc_service_register(test_ddev_svc, &sid);
115 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
116
117 rc = ddev_open(test_ddev_svc, &ddev);
118 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
119 PCUT_ASSERT_NOT_NULL(ddev);
120
121 gc = NULL;
122 resp.rc = ENOMEM;
123 rc = ddev_get_gc(ddev, &gc);
124 /* async_connect_me_to() does not return specific error */
125 PCUT_ASSERT_ERRNO_VAL(EIO, rc);
126 PCUT_ASSERT_NULL(gc);
127
128 ddev_close(ddev);
129 rc = loc_service_unregister(sid);
130 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
131}
132
133/** ddev_get_gc with server returning success */
134PCUT_TEST(dev_get_gc_success)
135{
136 errno_t rc;
137 service_id_t sid;
138 ddev_t *ddev = NULL;
139 test_response_t resp;
140 gfx_context_t *gc;
141 gfx_color_t *color;
142
143 async_set_fallback_port_handler(test_ddev_conn, &resp);
144
145 // FIXME This causes this test to be non-reentrant!
146 rc = loc_server_register(test_ddev_server);
147 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
148
149 rc = loc_service_register(test_ddev_svc, &sid);
150 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
151
152 rc = ddev_open(test_ddev_svc, &ddev);
153 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
154 PCUT_ASSERT_NOT_NULL(ddev);
155
156 resp.rc = EOK;
157 gc = NULL;
158 rc = ddev_get_gc(ddev, &gc);
159 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
160 PCUT_ASSERT_NOT_NULL(gc);
161
162 rc = gfx_color_new_rgb_i16(0, 0, 0, &color);
163 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
164
165 resp.set_color_called = false;
166 rc = gfx_set_color(gc, color);
167 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
168 PCUT_ASSERT_TRUE(resp.set_color_called);
169
170 gfx_color_delete(color);
171
172 ddev_close(ddev);
173 rc = loc_service_unregister(sid);
174 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
175}
176
177/** ddev_get_info with server returning failure */
178PCUT_TEST(dev_get_info_failure)
179{
180 errno_t rc;
181 service_id_t sid;
182 ddev_t *ddev = NULL;
183 test_response_t resp;
184 ddev_info_t info;
185
186 async_set_fallback_port_handler(test_ddev_conn, &resp);
187
188 // FIXME This causes this test to be non-reentrant!
189 rc = loc_server_register(test_ddev_server);
190 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
191
192 rc = loc_service_register(test_ddev_svc, &sid);
193 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
194
195 rc = ddev_open(test_ddev_svc, &ddev);
196 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
197 PCUT_ASSERT_NOT_NULL(ddev);
198
199 resp.rc = ENOMEM;
200 rc = ddev_get_info(ddev, &info);
201 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
202
203 ddev_close(ddev);
204 rc = loc_service_unregister(sid);
205 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
206}
207
208/** ddev_get_info with server returning success */
209PCUT_TEST(dev_get_info_success)
210{
211 errno_t rc;
212 service_id_t sid;
213 ddev_t *ddev = NULL;
214 test_response_t resp;
215 ddev_info_t info;
216
217 async_set_fallback_port_handler(test_ddev_conn, &resp);
218
219 // FIXME This causes this test to be non-reentrant!
220 rc = loc_server_register(test_ddev_server);
221 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
222
223 rc = loc_service_register(test_ddev_svc, &sid);
224 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
225
226 rc = ddev_open(test_ddev_svc, &ddev);
227 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
228 PCUT_ASSERT_NOT_NULL(ddev);
229
230 resp.rc = EOK;
231
232 ddev_info_init(&resp.info);
233 resp.info.rect.p0.x = 1;
234 resp.info.rect.p0.y = 2;
235 resp.info.rect.p1.x = 3;
236 resp.info.rect.p1.y = 4;
237
238 rc = ddev_get_info(ddev, &info);
239 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
240
241 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p0.x, info.rect.p0.x);
242 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p0.y, info.rect.p0.y);
243 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p1.x, info.rect.p1.x);
244 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p1.y, info.rect.p1.y);
245
246 ddev_close(ddev);
247 rc = loc_service_unregister(sid);
248 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
249}
250
251/** Test display device connection.
252 *
253 * This is very similar to connection handler in the display server.
254 * XXX This should be folded into display_srv, if possible
255 */
256static void test_ddev_conn(ipc_call_t *icall, void *arg)
257{
258 test_response_t *resp = (test_response_t *) arg;
259 ddev_srv_t srv;
260 sysarg_t svc_id;
261 gfx_context_t *gc;
262 errno_t rc;
263
264 svc_id = ipc_get_arg2(icall);
265
266 if (svc_id != 0) {
267 /* Set up protocol structure */
268 ddev_srv_initialize(&srv);
269 srv.ops = &test_ddev_ops;
270 srv.arg = arg;
271 resp->srv = &srv;
272
273 /* Handle connection */
274 ddev_conn(icall, &srv);
275
276 resp->srv = NULL;
277 } else {
278 if (resp->rc != EOK) {
279 async_answer_0(icall, resp->rc);
280 return;
281 }
282
283 rc = gfx_context_new(&test_gc_ops, arg, &gc);
284 if (rc != EOK) {
285 async_answer_0(icall, ENOMEM);
286 return;
287 }
288
289 /* GC connection */
290 gc_conn(icall, gc);
291 }
292}
293
294static errno_t test_get_gc(void *arg, sysarg_t *arg2, sysarg_t *arg3)
295{
296 *arg2 = 0;
297 *arg3 = 42;
298 return EOK;
299}
300
301static errno_t test_get_info(void *arg, ddev_info_t *info)
302{
303 test_response_t *resp = (test_response_t *) arg;
304
305 if (resp->rc != EOK)
306 return resp->rc;
307
308 *info = resp->info;
309 return EOK;
310}
311
312static errno_t test_gc_set_color(void *arg, gfx_color_t *color)
313{
314 test_response_t *resp = (test_response_t *) arg;
315
316 resp->set_color_called = true;
317 return resp->rc;
318}
319
320PCUT_EXPORT(ddev);
Note: See TracBrowser for help on using the repository browser.