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

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

Fix unit test

It seems the error code from the server side actually does go through.
  • Property mode set to 100644
File size: 7.9 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 PCUT_ASSERT_ERRNO_VAL(ENOMEM, rc);
125 PCUT_ASSERT_NULL(gc);
126
127 ddev_close(ddev);
128 rc = loc_service_unregister(sid);
129 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
130}
131
132/** ddev_get_gc with server returning success */
133PCUT_TEST(dev_get_gc_success)
134{
135 errno_t rc;
136 service_id_t sid;
137 ddev_t *ddev = NULL;
138 test_response_t resp;
139 gfx_context_t *gc;
140 gfx_color_t *color;
141
142 async_set_fallback_port_handler(test_ddev_conn, &resp);
143
144 // FIXME This causes this test to be non-reentrant!
145 rc = loc_server_register(test_ddev_server);
146 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
147
148 rc = loc_service_register(test_ddev_svc, &sid);
149 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
150
151 rc = ddev_open(test_ddev_svc, &ddev);
152 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
153 PCUT_ASSERT_NOT_NULL(ddev);
154
155 resp.rc = EOK;
156 gc = NULL;
157 rc = ddev_get_gc(ddev, &gc);
158 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
159 PCUT_ASSERT_NOT_NULL(gc);
160
161 rc = gfx_color_new_rgb_i16(0, 0, 0, &color);
162 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
163
164 resp.set_color_called = false;
165 rc = gfx_set_color(gc, color);
166 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
167 PCUT_ASSERT_TRUE(resp.set_color_called);
168
169 gfx_color_delete(color);
170
171 ddev_close(ddev);
172 rc = loc_service_unregister(sid);
173 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
174}
175
176/** ddev_get_info with server returning failure */
177PCUT_TEST(dev_get_info_failure)
178{
179 errno_t rc;
180 service_id_t sid;
181 ddev_t *ddev = NULL;
182 test_response_t resp;
183 ddev_info_t info;
184
185 async_set_fallback_port_handler(test_ddev_conn, &resp);
186
187 // FIXME This causes this test to be non-reentrant!
188 rc = loc_server_register(test_ddev_server);
189 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
190
191 rc = loc_service_register(test_ddev_svc, &sid);
192 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
193
194 rc = ddev_open(test_ddev_svc, &ddev);
195 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
196 PCUT_ASSERT_NOT_NULL(ddev);
197
198 resp.rc = ENOMEM;
199 rc = ddev_get_info(ddev, &info);
200 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
201
202 ddev_close(ddev);
203 rc = loc_service_unregister(sid);
204 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
205}
206
207/** ddev_get_info with server returning success */
208PCUT_TEST(dev_get_info_success)
209{
210 errno_t rc;
211 service_id_t sid;
212 ddev_t *ddev = NULL;
213 test_response_t resp;
214 ddev_info_t info;
215
216 async_set_fallback_port_handler(test_ddev_conn, &resp);
217
218 // FIXME This causes this test to be non-reentrant!
219 rc = loc_server_register(test_ddev_server);
220 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
221
222 rc = loc_service_register(test_ddev_svc, &sid);
223 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
224
225 rc = ddev_open(test_ddev_svc, &ddev);
226 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
227 PCUT_ASSERT_NOT_NULL(ddev);
228
229 resp.rc = EOK;
230
231 ddev_info_init(&resp.info);
232 resp.info.rect.p0.x = 1;
233 resp.info.rect.p0.y = 2;
234 resp.info.rect.p1.x = 3;
235 resp.info.rect.p1.y = 4;
236
237 rc = ddev_get_info(ddev, &info);
238 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
239
240 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p0.x, info.rect.p0.x);
241 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p0.y, info.rect.p0.y);
242 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p1.x, info.rect.p1.x);
243 PCUT_ASSERT_INT_EQUALS(resp.info.rect.p1.y, info.rect.p1.y);
244
245 ddev_close(ddev);
246 rc = loc_service_unregister(sid);
247 PCUT_ASSERT_ERRNO_VAL(EOK, rc);
248}
249
250/** Test display device connection.
251 *
252 * This is very similar to connection handler in the display server.
253 * XXX This should be folded into display_srv, if possible
254 */
255static void test_ddev_conn(ipc_call_t *icall, void *arg)
256{
257 test_response_t *resp = (test_response_t *) arg;
258 ddev_srv_t srv;
259 sysarg_t svc_id;
260 gfx_context_t *gc;
261 errno_t rc;
262
263 svc_id = ipc_get_arg2(icall);
264
265 if (svc_id != 0) {
266 /* Set up protocol structure */
267 ddev_srv_initialize(&srv);
268 srv.ops = &test_ddev_ops;
269 srv.arg = arg;
270 resp->srv = &srv;
271
272 /* Handle connection */
273 ddev_conn(icall, &srv);
274
275 resp->srv = NULL;
276 } else {
277 if (resp->rc != EOK) {
278 async_answer_0(icall, resp->rc);
279 return;
280 }
281
282 rc = gfx_context_new(&test_gc_ops, arg, &gc);
283 if (rc != EOK) {
284 async_answer_0(icall, ENOMEM);
285 return;
286 }
287
288 /* GC connection */
289 gc_conn(icall, gc);
290 }
291}
292
293static errno_t test_get_gc(void *arg, sysarg_t *arg2, sysarg_t *arg3)
294{
295 *arg2 = 0;
296 *arg3 = 42;
297 return EOK;
298}
299
300static errno_t test_get_info(void *arg, ddev_info_t *info)
301{
302 test_response_t *resp = (test_response_t *) arg;
303
304 if (resp->rc != EOK)
305 return resp->rc;
306
307 *info = resp->info;
308 return EOK;
309}
310
311static errno_t test_gc_set_color(void *arg, gfx_color_t *color)
312{
313 test_response_t *resp = (test_response_t *) arg;
314
315 resp->set_color_called = true;
316 return resp->rc;
317}
318
319PCUT_EXPORT(ddev);
Note: See TracBrowser for help on using the repository browser.