Changes in uspace/lib/display/test/display.c [c9927c66:4c6fd56] in mainline
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/display/test/display.c
rc9927c66 r4c6fd56 1 1 /* 2 * Copyright (c) 202 1Jiri Svoboda2 * Copyright (c) 2023 Jiri Svoboda 3 3 * All rights reserved. 4 4 * … … 38 38 #include <loc.h> 39 39 #include <pcut/pcut.h> 40 #include <str.h> 40 41 #include "../private/display.h" 41 42 … … 50 51 51 52 static void test_close_event(void *); 52 static void test_focus_event(void * );53 static void test_focus_event(void *, unsigned); 53 54 static void test_kbd_event(void *, kbd_event_t *); 54 55 static void test_pos_event(void *, pos_event_t *); 55 static void test_unfocus_event(void * );56 static void test_unfocus_event(void *, unsigned); 56 57 57 58 static errno_t test_window_create(void *, display_wnd_params_t *, sysarg_t *); 58 59 static errno_t test_window_destroy(void *, sysarg_t); 59 static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t * );60 static errno_t test_window_move_req(void *, sysarg_t, gfx_coord2_t *, sysarg_t); 60 61 static errno_t test_window_move(void *, sysarg_t, gfx_coord2_t *); 61 62 static errno_t test_window_get_pos(void *, sysarg_t, gfx_coord2_t *); 63 static errno_t test_window_get_max_rect(void *, sysarg_t, gfx_rect_t *); 62 64 static errno_t test_window_resize_req(void *, sysarg_t, display_wnd_rsztype_t, 63 gfx_coord2_t * );65 gfx_coord2_t *, sysarg_t); 64 66 static errno_t test_window_resize(void *, sysarg_t, gfx_coord2_t *, 65 67 gfx_rect_t *); 68 static errno_t test_window_minimize(void *, sysarg_t); 69 static errno_t test_window_maximize(void *, sysarg_t); 70 static errno_t test_window_unmaximize(void *, sysarg_t); 66 71 static errno_t test_window_set_cursor(void *, sysarg_t, display_stock_cursor_t); 72 static errno_t test_window_set_caption(void *, sysarg_t, const char *); 67 73 static errno_t test_get_event(void *, sysarg_t *, display_wnd_ev_t *); 68 74 static errno_t test_get_info(void *, display_info_t *); … … 76 82 .window_move = test_window_move, 77 83 .window_get_pos = test_window_get_pos, 84 .window_get_max_rect = test_window_get_max_rect, 78 85 .window_resize_req = test_window_resize_req, 79 86 .window_resize = test_window_resize, 87 .window_minimize = test_window_minimize, 88 .window_maximize = test_window_maximize, 89 .window_unmaximize = test_window_unmaximize, 80 90 .window_set_cursor = test_window_set_cursor, 91 .window_set_caption = test_window_set_caption, 81 92 .get_event = test_get_event, 82 93 .get_info = test_get_info … … 107 118 gfx_rect_t create_rect; 108 119 gfx_coord2_t create_min_size; 120 sysarg_t create_idev_id; 109 121 bool window_destroy_called; 110 122 sysarg_t destroy_wnd_id; … … 113 125 sysarg_t move_req_wnd_id; 114 126 gfx_coord2_t move_req_pos; 127 sysarg_t move_req_pos_id; 115 128 116 129 bool window_move_called; … … 121 134 sysarg_t get_pos_wnd_id; 122 135 gfx_coord2_t get_pos_rpos; 136 137 bool window_get_max_rect_called; 138 sysarg_t get_max_rect_wnd_id; 139 gfx_rect_t get_max_rect_rrect; 123 140 124 141 bool window_resize_req_called; … … 126 143 display_wnd_rsztype_t resize_req_rsztype; 127 144 gfx_coord2_t resize_req_pos; 145 sysarg_t resize_req_pos_id; 128 146 129 147 bool window_resize_called; … … 132 150 sysarg_t resize_wnd_id; 133 151 152 bool window_minimize_called; 153 bool window_maximize_called; 154 bool window_unmaximize_called; 155 134 156 bool window_set_cursor_called; 135 157 sysarg_t set_cursor_wnd_id; 136 158 display_stock_cursor_t set_cursor_cursor; 137 159 160 bool window_set_caption_called; 161 sysarg_t set_caption_wnd_id; 162 char *set_caption_caption; 163 138 164 bool get_event_called; 139 165 … … 143 169 bool set_color_called; 144 170 bool close_event_called; 171 145 172 bool focus_event_called; 146 173 bool kbd_event_called; … … 159 186 display_t *disp = NULL; 160 187 test_response_t resp; 161 162 async_set_fallback_port_handler(test_display_conn, &resp); 163 164 // FIXME This causes this test to be non-reentrant! 165 rc = loc_server_register(test_display_server); 166 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 167 168 rc = loc_service_register(test_display_svc, &sid); 169 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 170 171 rc = display_open(test_display_svc, &disp); 172 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 173 PCUT_ASSERT_NOT_NULL(disp); 174 175 display_close(disp); 176 rc = loc_service_unregister(sid); 177 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 188 loc_srv_t *srv; 189 190 async_set_fallback_port_handler(test_display_conn, &resp); 191 192 // FIXME This causes this test to be non-reentrant! 193 rc = loc_server_register(test_display_server, &srv); 194 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 195 196 rc = loc_service_register(srv, test_display_svc, &sid); 197 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 198 199 rc = display_open(test_display_svc, &disp); 200 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 201 PCUT_ASSERT_NOT_NULL(disp); 202 203 display_close(disp); 204 rc = loc_service_unregister(srv, sid); 205 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 206 loc_server_unregister(srv); 178 207 } 179 208 … … 187 216 display_window_t *wnd; 188 217 test_response_t resp; 189 190 async_set_fallback_port_handler(test_display_conn, &resp); 191 192 // FIXME This causes this test to be non-reentrant! 193 rc = loc_server_register(test_display_server); 194 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 195 196 rc = loc_service_register(test_display_svc, &sid); 218 loc_srv_t *srv; 219 220 async_set_fallback_port_handler(test_display_conn, &resp); 221 222 // FIXME This causes this test to be non-reentrant! 223 rc = loc_server_register(test_display_server, &srv); 224 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 225 226 rc = loc_service_register(srv, test_display_svc, &sid); 197 227 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 198 228 … … 211 241 params.min_size.x = 11; 212 242 params.min_size.y = 12; 243 params.idev_id = 42; 213 244 214 245 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, … … 221 252 PCUT_ASSERT_EQUALS(params.min_size.x, resp.create_min_size.x); 222 253 PCUT_ASSERT_EQUALS(params.min_size.y, resp.create_min_size.y); 254 PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id); 223 255 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 224 256 PCUT_ASSERT_NULL(wnd); 225 257 226 258 display_close(disp); 227 rc = loc_service_unregister(sid); 228 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 259 rc = loc_service_unregister(srv, sid); 260 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 261 loc_server_unregister(srv); 229 262 } 230 263 … … 241 274 display_window_t *wnd; 242 275 test_response_t resp; 243 244 async_set_fallback_port_handler(test_display_conn, &resp); 245 246 // FIXME This causes this test to be non-reentrant! 247 rc = loc_server_register(test_display_server); 248 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 249 250 rc = loc_service_register(test_display_svc, &sid); 276 loc_srv_t *srv; 277 278 async_set_fallback_port_handler(test_display_conn, &resp); 279 280 // FIXME This causes this test to be non-reentrant! 281 rc = loc_server_register(test_display_server, &srv); 282 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 283 284 rc = loc_service_register(srv, test_display_svc, &sid); 251 285 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 252 286 … … 263 297 params.rect.p0.x = 100; 264 298 params.rect.p0.y = 100; 299 params.idev_id = 42; 265 300 266 301 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, … … 271 306 PCUT_ASSERT_EQUALS(params.rect.p1.x, resp.create_rect.p1.x); 272 307 PCUT_ASSERT_EQUALS(params.rect.p1.y, resp.create_rect.p1.y); 308 PCUT_ASSERT_EQUALS(params.idev_id, resp.create_idev_id); 273 309 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 274 310 PCUT_ASSERT_NOT_NULL(wnd); … … 281 317 282 318 display_close(disp); 283 rc = loc_service_unregister(sid); 284 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 319 rc = loc_service_unregister(srv, sid); 320 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 321 loc_server_unregister(srv); 285 322 } 286 323 … … 294 331 display_window_t *wnd; 295 332 test_response_t resp; 296 297 async_set_fallback_port_handler(test_display_conn, &resp); 298 299 // FIXME This causes this test to be non-reentrant! 300 rc = loc_server_register(test_display_server); 301 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 302 303 rc = loc_service_register(test_display_svc, &sid); 333 loc_srv_t *srv; 334 335 async_set_fallback_port_handler(test_display_conn, &resp); 336 337 // FIXME This causes this test to be non-reentrant! 338 rc = loc_server_register(test_display_server, &srv); 339 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 340 341 rc = loc_service_register(srv, test_display_svc, &sid); 304 342 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 305 343 … … 334 372 335 373 display_close(disp); 336 rc = loc_service_unregister(sid); 337 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 374 rc = loc_service_unregister(srv, sid); 375 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 376 loc_server_unregister(srv); 338 377 } 339 378 … … 354 393 test_response_t resp; 355 394 gfx_coord2_t pos; 356 357 async_set_fallback_port_handler(test_display_conn, &resp); 358 359 // FIXME This causes this test to be non-reentrant! 360 rc = loc_server_register(test_display_server); 361 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 362 363 rc = loc_service_register(test_display_svc, &sid); 395 sysarg_t pos_id; 396 loc_srv_t *srv; 397 398 async_set_fallback_port_handler(test_display_conn, &resp); 399 400 // FIXME This causes this test to be non-reentrant! 401 rc = loc_server_register(test_display_server, &srv); 402 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 403 404 rc = loc_service_register(srv, test_display_svc, &sid); 364 405 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 365 406 … … 385 426 pos.x = 42; 386 427 pos.y = 43; 387 388 rc = display_window_move_req(wnd, &pos); 428 pos_id = 44; 429 430 rc = display_window_move_req(wnd, &pos, pos_id); 389 431 PCUT_ASSERT_TRUE(resp.window_move_req_called); 390 432 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); … … 392 434 PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x); 393 435 PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y); 436 PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id); 394 437 395 438 display_window_destroy(wnd); 396 439 display_close(disp); 397 rc = loc_service_unregister(sid); 398 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 440 rc = loc_service_unregister(srv, sid); 441 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 442 loc_server_unregister(srv); 399 443 } 400 444 … … 409 453 test_response_t resp; 410 454 gfx_coord2_t pos; 411 412 async_set_fallback_port_handler(test_display_conn, &resp); 413 414 // FIXME This causes this test to be non-reentrant! 415 rc = loc_server_register(test_display_server); 416 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 417 418 rc = loc_service_register(test_display_svc, &sid); 455 sysarg_t pos_id; 456 loc_srv_t *srv; 457 458 async_set_fallback_port_handler(test_display_conn, &resp); 459 460 // FIXME This causes this test to be non-reentrant! 461 rc = loc_server_register(test_display_server, &srv); 462 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 463 464 rc = loc_service_register(srv, test_display_svc, &sid); 419 465 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 420 466 … … 440 486 pos.x = 42; 441 487 pos.y = 43; 442 443 rc = display_window_move_req(wnd, &pos); 488 pos_id = 44; 489 490 rc = display_window_move_req(wnd, &pos, pos_id); 444 491 PCUT_ASSERT_TRUE(resp.window_move_req_called); 445 492 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); … … 447 494 PCUT_ASSERT_INT_EQUALS(pos.x, resp.move_req_pos.x); 448 495 PCUT_ASSERT_INT_EQUALS(pos.y, resp.move_req_pos.y); 496 PCUT_ASSERT_INT_EQUALS(pos_id, resp.move_req_pos_id); 449 497 450 498 display_window_destroy(wnd); 451 499 display_close(disp); 452 rc = loc_service_unregister(sid); 453 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 500 rc = loc_service_unregister(srv, sid); 501 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 502 loc_server_unregister(srv); 454 503 } 455 504 … … 464 513 gfx_coord2_t dpos; 465 514 test_response_t resp; 466 467 async_set_fallback_port_handler(test_display_conn, &resp); 468 469 // FIXME This causes this test to be non-reentrant! 470 rc = loc_server_register(test_display_server); 471 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 472 473 rc = loc_service_register(test_display_svc, &sid); 515 loc_srv_t *srv; 516 517 async_set_fallback_port_handler(test_display_conn, &resp); 518 519 // FIXME This causes this test to be non-reentrant! 520 rc = loc_server_register(test_display_server, &srv); 521 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 522 523 rc = loc_service_register(srv, test_display_svc, &sid); 474 524 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 475 525 … … 504 554 display_window_destroy(wnd); 505 555 display_close(disp); 506 rc = loc_service_unregister(sid); 507 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 556 rc = loc_service_unregister(srv, sid); 557 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 558 loc_server_unregister(srv); 508 559 } 509 560 … … 518 569 gfx_coord2_t dpos; 519 570 test_response_t resp; 520 521 async_set_fallback_port_handler(test_display_conn, &resp); 522 523 // FIXME This causes this test to be non-reentrant! 524 rc = loc_server_register(test_display_server); 525 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 526 527 rc = loc_service_register(test_display_svc, &sid); 571 loc_srv_t *srv; 572 573 async_set_fallback_port_handler(test_display_conn, &resp); 574 575 // FIXME This causes this test to be non-reentrant! 576 rc = loc_server_register(test_display_server, &srv); 577 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 578 579 rc = loc_service_register(srv, test_display_svc, &sid); 528 580 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 529 581 … … 558 610 display_window_destroy(wnd); 559 611 display_close(disp); 560 rc = loc_service_unregister(sid); 561 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 612 rc = loc_service_unregister(srv, sid); 613 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 614 loc_server_unregister(srv); 562 615 } 563 616 … … 572 625 gfx_coord2_t dpos; 573 626 test_response_t resp; 574 575 async_set_fallback_port_handler(test_display_conn, &resp); 576 577 // FIXME This causes this test to be non-reentrant! 578 rc = loc_server_register(test_display_server); 579 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 580 581 rc = loc_service_register(test_display_svc, &sid); 627 loc_srv_t *srv; 628 629 async_set_fallback_port_handler(test_display_conn, &resp); 630 631 // FIXME This causes this test to be non-reentrant! 632 rc = loc_server_register(test_display_server, &srv); 633 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 634 635 rc = loc_service_register(srv, test_display_svc, &sid); 582 636 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 583 637 … … 613 667 display_window_destroy(wnd); 614 668 display_close(disp); 615 rc = loc_service_unregister(sid); 616 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 669 rc = loc_service_unregister(srv, sid); 670 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 671 loc_server_unregister(srv); 617 672 } 618 673 … … 627 682 gfx_coord2_t dpos; 628 683 test_response_t resp; 629 630 async_set_fallback_port_handler(test_display_conn, &resp); 631 632 // FIXME This causes this test to be non-reentrant! 633 rc = loc_server_register(test_display_server); 634 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 635 636 rc = loc_service_register(test_display_svc, &sid); 684 loc_srv_t *srv; 685 686 async_set_fallback_port_handler(test_display_conn, &resp); 687 688 // FIXME This causes this test to be non-reentrant! 689 rc = loc_server_register(test_display_server, &srv); 690 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 691 692 rc = loc_service_register(srv, test_display_svc, &sid); 637 693 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 638 694 … … 670 726 display_window_destroy(wnd); 671 727 display_close(disp); 672 rc = loc_service_unregister(sid); 673 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 728 rc = loc_service_unregister(srv, sid); 729 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 730 loc_server_unregister(srv); 731 } 732 733 /** display_window_get_max_rect() with server returning error response works. */ 734 PCUT_TEST(window_get_max_rect_failure) 735 { 736 errno_t rc; 737 service_id_t sid; 738 display_t *disp = NULL; 739 display_wnd_params_t params; 740 display_window_t *wnd; 741 gfx_rect_t rect; 742 test_response_t resp; 743 loc_srv_t *srv; 744 745 async_set_fallback_port_handler(test_display_conn, &resp); 746 747 // FIXME This causes this test to be non-reentrant! 748 rc = loc_server_register(test_display_server, &srv); 749 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 750 751 rc = loc_service_register(srv, test_display_svc, &sid); 752 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 753 754 rc = display_open(test_display_svc, &disp); 755 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 756 PCUT_ASSERT_NOT_NULL(disp); 757 758 resp.rc = EOK; 759 display_wnd_params_init(¶ms); 760 params.rect.p0.x = 0; 761 params.rect.p0.y = 0; 762 params.rect.p0.x = 100; 763 params.rect.p0.y = 100; 764 765 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 766 (void *) &resp, &wnd); 767 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 768 PCUT_ASSERT_NOT_NULL(wnd); 769 770 resp.rc = EIO; 771 resp.window_get_max_rect_called = false; 772 773 rect.p0.x = 0; 774 rect.p0.y = 0; 775 rect.p1.x = 0; 776 rect.p1.y = 0; 777 778 rc = display_window_get_max_rect(wnd, &rect); 779 PCUT_ASSERT_TRUE(resp.window_get_max_rect_called); 780 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 781 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id); 782 PCUT_ASSERT_INT_EQUALS(0, rect.p0.x); 783 PCUT_ASSERT_INT_EQUALS(0, rect.p0.y); 784 PCUT_ASSERT_INT_EQUALS(0, rect.p1.x); 785 PCUT_ASSERT_INT_EQUALS(0, rect.p1.y); 786 787 display_window_destroy(wnd); 788 display_close(disp); 789 rc = loc_service_unregister(srv, sid); 790 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 791 loc_server_unregister(srv); 792 } 793 794 /** display_window_get_max_rect() with server returning success response works. */ 795 PCUT_TEST(window_get_max_rect_success) 796 { 797 errno_t rc; 798 service_id_t sid; 799 display_t *disp = NULL; 800 display_wnd_params_t params; 801 display_window_t *wnd; 802 gfx_rect_t rect; 803 test_response_t resp; 804 loc_srv_t *srv; 805 806 async_set_fallback_port_handler(test_display_conn, &resp); 807 808 // FIXME This causes this test to be non-reentrant! 809 rc = loc_server_register(test_display_server, &srv); 810 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 811 812 rc = loc_service_register(srv, test_display_svc, &sid); 813 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 814 815 rc = display_open(test_display_svc, &disp); 816 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 817 PCUT_ASSERT_NOT_NULL(disp); 818 819 resp.rc = EOK; 820 display_wnd_params_init(¶ms); 821 params.rect.p0.x = 0; 822 params.rect.p0.y = 0; 823 params.rect.p0.x = 100; 824 params.rect.p0.y = 100; 825 826 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 827 (void *) &resp, &wnd); 828 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 829 PCUT_ASSERT_NOT_NULL(wnd); 830 831 resp.rc = EOK; 832 resp.window_get_max_rect_called = false; 833 resp.get_max_rect_rrect.p0.x = 11; 834 resp.get_max_rect_rrect.p0.y = 12; 835 resp.get_max_rect_rrect.p1.x = 13; 836 resp.get_max_rect_rrect.p1.y = 14; 837 838 rect.p0.x = 0; 839 rect.p0.y = 0; 840 rect.p1.x = 0; 841 rect.p1.y = 0; 842 843 rc = display_window_get_max_rect(wnd, &rect); 844 PCUT_ASSERT_TRUE(resp.window_get_max_rect_called); 845 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 846 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.get_max_rect_wnd_id); 847 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.x, rect.p0.x); 848 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p0.y, rect.p0.y); 849 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.x, rect.p1.x); 850 PCUT_ASSERT_INT_EQUALS(resp.get_max_rect_rrect.p1.y, rect.p1.y); 851 852 display_window_destroy(wnd); 853 display_close(disp); 854 rc = loc_service_unregister(srv, sid); 855 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 856 loc_server_unregister(srv); 674 857 } 675 858 … … 685 868 display_wnd_rsztype_t rsztype; 686 869 gfx_coord2_t pos; 687 688 async_set_fallback_port_handler(test_display_conn, &resp); 689 690 // FIXME This causes this test to be non-reentrant! 691 rc = loc_server_register(test_display_server); 692 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 693 694 rc = loc_service_register(test_display_svc, &sid); 870 sysarg_t pos_id; 871 loc_srv_t *srv; 872 873 async_set_fallback_port_handler(test_display_conn, &resp); 874 875 // FIXME This causes this test to be non-reentrant! 876 rc = loc_server_register(test_display_server, &srv); 877 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 878 879 rc = loc_service_register(srv, test_display_svc, &sid); 695 880 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 696 881 … … 717 902 pos.x = 42; 718 903 pos.y = 43; 719 720 rc = display_window_resize_req(wnd, rsztype, &pos); 904 pos_id = 44; 905 906 rc = display_window_resize_req(wnd, rsztype, &pos, pos_id); 721 907 PCUT_ASSERT_TRUE(resp.window_resize_req_called); 722 908 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); … … 725 911 PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x); 726 912 PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y); 913 PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id); 727 914 728 915 display_window_destroy(wnd); 729 916 display_close(disp); 730 rc = loc_service_unregister(sid); 731 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 917 rc = loc_service_unregister(srv, sid); 918 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 919 loc_server_unregister(srv); 732 920 } 733 921 … … 743 931 display_wnd_rsztype_t rsztype; 744 932 gfx_coord2_t pos; 745 746 async_set_fallback_port_handler(test_display_conn, &resp); 747 748 // FIXME This causes this test to be non-reentrant! 749 rc = loc_server_register(test_display_server); 750 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 751 752 rc = loc_service_register(test_display_svc, &sid); 933 sysarg_t pos_id; 934 loc_srv_t *srv; 935 936 async_set_fallback_port_handler(test_display_conn, &resp); 937 938 // FIXME This causes this test to be non-reentrant! 939 rc = loc_server_register(test_display_server, &srv); 940 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 941 942 rc = loc_service_register(srv, test_display_svc, &sid); 753 943 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 754 944 … … 775 965 pos.x = 42; 776 966 pos.y = 43; 777 778 rc = display_window_resize_req(wnd, rsztype, &pos); 967 pos_id = 44; 968 969 rc = display_window_resize_req(wnd, rsztype, &pos, pos_id); 779 970 PCUT_ASSERT_TRUE(resp.window_resize_req_called); 780 971 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); … … 783 974 PCUT_ASSERT_INT_EQUALS(pos.x, resp.resize_req_pos.x); 784 975 PCUT_ASSERT_INT_EQUALS(pos.y, resp.resize_req_pos.y); 976 PCUT_ASSERT_INT_EQUALS(pos_id, resp.resize_req_pos_id); 785 977 786 978 display_window_destroy(wnd); 787 979 display_close(disp); 788 rc = loc_service_unregister(sid); 789 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 980 rc = loc_service_unregister(srv, sid); 981 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 982 loc_server_unregister(srv); 790 983 } 791 984 … … 801 994 gfx_rect_t nrect; 802 995 test_response_t resp; 803 804 async_set_fallback_port_handler(test_display_conn, &resp); 805 806 // FIXME This causes this test to be non-reentrant! 807 rc = loc_server_register(test_display_server); 808 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 809 810 rc = loc_service_register(test_display_svc, &sid); 996 loc_srv_t *srv; 997 998 async_set_fallback_port_handler(test_display_conn, &resp); 999 1000 // FIXME This causes this test to be non-reentrant! 1001 rc = loc_server_register(test_display_server, &srv); 1002 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1003 1004 rc = loc_service_register(srv, test_display_svc, &sid); 811 1005 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 812 1006 … … 849 1043 display_window_destroy(wnd); 850 1044 display_close(disp); 851 rc = loc_service_unregister(sid); 852 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1045 rc = loc_service_unregister(srv, sid); 1046 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1047 loc_server_unregister(srv); 853 1048 } 854 1049 … … 864 1059 gfx_rect_t nrect; 865 1060 test_response_t resp; 866 867 async_set_fallback_port_handler(test_display_conn, &resp); 868 869 // FIXME This causes this test to be non-reentrant! 870 rc = loc_server_register(test_display_server); 871 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 872 873 rc = loc_service_register(test_display_svc, &sid); 1061 loc_srv_t *srv; 1062 1063 async_set_fallback_port_handler(test_display_conn, &resp); 1064 1065 // FIXME This causes this test to be non-reentrant! 1066 rc = loc_server_register(test_display_server, &srv); 1067 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1068 1069 rc = loc_service_register(srv, test_display_svc, &sid); 874 1070 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 875 1071 … … 911 1107 display_window_destroy(wnd); 912 1108 display_close(disp); 913 rc = loc_service_unregister(sid); 914 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1109 rc = loc_service_unregister(srv, sid); 1110 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1111 loc_server_unregister(srv); 1112 } 1113 1114 /** display_window_minimize() with server returning error response works. */ 1115 PCUT_TEST(window_minimize_failure) 1116 { 1117 errno_t rc; 1118 service_id_t sid; 1119 display_t *disp = NULL; 1120 display_wnd_params_t params; 1121 display_window_t *wnd; 1122 test_response_t resp; 1123 loc_srv_t *srv; 1124 1125 async_set_fallback_port_handler(test_display_conn, &resp); 1126 1127 // FIXME This causes this test to be non-reentrant! 1128 rc = loc_server_register(test_display_server, &srv); 1129 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1130 1131 rc = loc_service_register(srv, test_display_svc, &sid); 1132 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1133 1134 rc = display_open(test_display_svc, &disp); 1135 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1136 PCUT_ASSERT_NOT_NULL(disp); 1137 1138 resp.rc = EOK; 1139 display_wnd_params_init(¶ms); 1140 params.rect.p0.x = 0; 1141 params.rect.p0.y = 0; 1142 params.rect.p0.x = 100; 1143 params.rect.p0.y = 100; 1144 1145 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1146 (void *) &resp, &wnd); 1147 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1148 PCUT_ASSERT_NOT_NULL(wnd); 1149 1150 resp.rc = EIO; 1151 resp.window_minimize_called = false; 1152 1153 rc = display_window_minimize(wnd); 1154 PCUT_ASSERT_TRUE(resp.window_minimize_called); 1155 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1156 1157 display_window_destroy(wnd); 1158 display_close(disp); 1159 rc = loc_service_unregister(srv, sid); 1160 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1161 loc_server_unregister(srv); 1162 } 1163 1164 /** display_window_minimize() with server returning success response works. */ 1165 PCUT_TEST(window_minimize_success) 1166 { 1167 errno_t rc; 1168 service_id_t sid; 1169 display_t *disp = NULL; 1170 display_wnd_params_t params; 1171 display_window_t *wnd; 1172 test_response_t resp; 1173 loc_srv_t *srv; 1174 1175 async_set_fallback_port_handler(test_display_conn, &resp); 1176 1177 // FIXME This causes this test to be non-reentrant! 1178 rc = loc_server_register(test_display_server, &srv); 1179 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1180 1181 rc = loc_service_register(srv, test_display_svc, &sid); 1182 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1183 1184 rc = display_open(test_display_svc, &disp); 1185 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1186 PCUT_ASSERT_NOT_NULL(disp); 1187 1188 resp.rc = EOK; 1189 display_wnd_params_init(¶ms); 1190 params.rect.p0.x = 0; 1191 params.rect.p0.y = 0; 1192 params.rect.p0.x = 100; 1193 params.rect.p0.y = 100; 1194 1195 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1196 (void *) &resp, &wnd); 1197 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1198 PCUT_ASSERT_NOT_NULL(wnd); 1199 1200 resp.rc = EOK; 1201 resp.window_minimize_called = false; 1202 1203 rc = display_window_minimize(wnd); 1204 PCUT_ASSERT_TRUE(resp.window_minimize_called); 1205 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1206 1207 display_window_destroy(wnd); 1208 display_close(disp); 1209 rc = loc_service_unregister(srv, sid); 1210 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1211 loc_server_unregister(srv); 1212 } 1213 1214 /** display_window_maximize() with server returning error response works. */ 1215 PCUT_TEST(window_maximize_failure) 1216 { 1217 errno_t rc; 1218 service_id_t sid; 1219 display_t *disp = NULL; 1220 display_wnd_params_t params; 1221 display_window_t *wnd; 1222 test_response_t resp; 1223 loc_srv_t *srv; 1224 1225 async_set_fallback_port_handler(test_display_conn, &resp); 1226 1227 // FIXME This causes this test to be non-reentrant! 1228 rc = loc_server_register(test_display_server, &srv); 1229 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1230 1231 rc = loc_service_register(srv, test_display_svc, &sid); 1232 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1233 1234 rc = display_open(test_display_svc, &disp); 1235 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1236 PCUT_ASSERT_NOT_NULL(disp); 1237 1238 resp.rc = EOK; 1239 display_wnd_params_init(¶ms); 1240 params.rect.p0.x = 0; 1241 params.rect.p0.y = 0; 1242 params.rect.p0.x = 100; 1243 params.rect.p0.y = 100; 1244 1245 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1246 (void *) &resp, &wnd); 1247 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1248 PCUT_ASSERT_NOT_NULL(wnd); 1249 1250 resp.rc = EIO; 1251 resp.window_maximize_called = false; 1252 1253 rc = display_window_maximize(wnd); 1254 PCUT_ASSERT_TRUE(resp.window_maximize_called); 1255 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1256 1257 display_window_destroy(wnd); 1258 display_close(disp); 1259 rc = loc_service_unregister(srv, sid); 1260 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1261 loc_server_unregister(srv); 1262 } 1263 1264 /** display_window_maximize() with server returning success response works. */ 1265 PCUT_TEST(window_maximize_success) 1266 { 1267 errno_t rc; 1268 service_id_t sid; 1269 display_t *disp = NULL; 1270 display_wnd_params_t params; 1271 display_window_t *wnd; 1272 test_response_t resp; 1273 loc_srv_t *srv; 1274 1275 async_set_fallback_port_handler(test_display_conn, &resp); 1276 1277 // FIXME This causes this test to be non-reentrant! 1278 rc = loc_server_register(test_display_server, &srv); 1279 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1280 1281 rc = loc_service_register(srv, test_display_svc, &sid); 1282 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1283 1284 rc = display_open(test_display_svc, &disp); 1285 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1286 PCUT_ASSERT_NOT_NULL(disp); 1287 1288 resp.rc = EOK; 1289 display_wnd_params_init(¶ms); 1290 params.rect.p0.x = 0; 1291 params.rect.p0.y = 0; 1292 params.rect.p0.x = 100; 1293 params.rect.p0.y = 100; 1294 1295 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1296 (void *) &resp, &wnd); 1297 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1298 PCUT_ASSERT_NOT_NULL(wnd); 1299 1300 resp.rc = EOK; 1301 resp.window_maximize_called = false; 1302 1303 rc = display_window_maximize(wnd); 1304 PCUT_ASSERT_TRUE(resp.window_maximize_called); 1305 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1306 1307 display_window_destroy(wnd); 1308 display_close(disp); 1309 rc = loc_service_unregister(srv, sid); 1310 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1311 loc_server_unregister(srv); 915 1312 } 916 1313 … … 924 1321 display_window_t *wnd; 925 1322 test_response_t resp; 926 927 async_set_fallback_port_handler(test_display_conn, &resp); 928 929 // FIXME This causes this test to be non-reentrant! 930 rc = loc_server_register(test_display_server); 931 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 932 933 rc = loc_service_register(test_display_svc, &sid); 1323 loc_srv_t *srv; 1324 1325 async_set_fallback_port_handler(test_display_conn, &resp); 1326 1327 // FIXME This causes this test to be non-reentrant! 1328 rc = loc_server_register(test_display_server, &srv); 1329 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1330 1331 rc = loc_service_register(srv, test_display_svc, &sid); 934 1332 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 935 1333 … … 961 1359 display_window_destroy(wnd); 962 1360 display_close(disp); 963 rc = loc_service_unregister(sid); 964 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1361 rc = loc_service_unregister(srv, sid); 1362 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1363 loc_server_unregister(srv); 965 1364 } 966 1365 … … 974 1373 display_window_t *wnd; 975 1374 test_response_t resp; 976 977 async_set_fallback_port_handler(test_display_conn, &resp); 978 979 // FIXME This causes this test to be non-reentrant! 980 rc = loc_server_register(test_display_server); 981 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 982 983 rc = loc_service_register(test_display_svc, &sid); 1375 loc_srv_t *srv; 1376 1377 async_set_fallback_port_handler(test_display_conn, &resp); 1378 1379 // FIXME This causes this test to be non-reentrant! 1380 rc = loc_server_register(test_display_server, &srv); 1381 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1382 1383 rc = loc_service_register(srv, test_display_svc, &sid); 984 1384 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 985 1385 … … 1011 1411 display_window_destroy(wnd); 1012 1412 display_close(disp); 1013 rc = loc_service_unregister(sid); 1014 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1413 rc = loc_service_unregister(srv, sid); 1414 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1415 loc_server_unregister(srv); 1416 } 1417 1418 /** display_window_set_caption() with server returning error response works. */ 1419 PCUT_TEST(window_set_caption_failure) 1420 { 1421 errno_t rc; 1422 service_id_t sid; 1423 display_t *disp = NULL; 1424 display_wnd_params_t params; 1425 display_window_t *wnd; 1426 const char *caption; 1427 test_response_t resp; 1428 loc_srv_t *srv; 1429 1430 async_set_fallback_port_handler(test_display_conn, &resp); 1431 1432 // FIXME This causes this test to be non-reentrant! 1433 rc = loc_server_register(test_display_server, &srv); 1434 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1435 1436 rc = loc_service_register(srv, test_display_svc, &sid); 1437 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1438 1439 rc = display_open(test_display_svc, &disp); 1440 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1441 PCUT_ASSERT_NOT_NULL(disp); 1442 1443 resp.rc = EOK; 1444 display_wnd_params_init(¶ms); 1445 params.rect.p0.x = 0; 1446 params.rect.p0.y = 0; 1447 params.rect.p0.x = 100; 1448 params.rect.p0.y = 100; 1449 1450 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1451 (void *) &resp, &wnd); 1452 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1453 PCUT_ASSERT_NOT_NULL(wnd); 1454 1455 caption = "Hello"; 1456 1457 resp.rc = EIO; 1458 resp.window_set_caption_called = false; 1459 1460 rc = display_window_set_caption(wnd, caption); 1461 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id); 1462 PCUT_ASSERT_TRUE(resp.window_set_caption_called); 1463 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1464 PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption)); 1465 1466 //free(resp.set_caption_caption); 1467 display_window_destroy(wnd); 1468 display_close(disp); 1469 rc = loc_service_unregister(srv, sid); 1470 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1471 loc_server_unregister(srv); 1472 } 1473 1474 /** display_window_set_caption() with server returning success response works. */ 1475 PCUT_TEST(window_set_caption_success) 1476 { 1477 errno_t rc; 1478 service_id_t sid; 1479 display_t *disp = NULL; 1480 display_wnd_params_t params; 1481 display_window_t *wnd; 1482 const char *caption; 1483 test_response_t resp; 1484 loc_srv_t *srv; 1485 1486 async_set_fallback_port_handler(test_display_conn, &resp); 1487 1488 // FIXME This causes this test to be non-reentrant! 1489 rc = loc_server_register(test_display_server, &srv); 1490 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1491 1492 rc = loc_service_register(srv, test_display_svc, &sid); 1493 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1494 1495 rc = display_open(test_display_svc, &disp); 1496 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1497 PCUT_ASSERT_NOT_NULL(disp); 1498 1499 resp.rc = EOK; 1500 display_wnd_params_init(¶ms); 1501 params.rect.p0.x = 0; 1502 params.rect.p0.y = 0; 1503 params.rect.p0.x = 100; 1504 params.rect.p0.y = 100; 1505 1506 rc = display_window_create(disp, ¶ms, &test_display_wnd_cb, 1507 (void *) &resp, &wnd); 1508 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1509 PCUT_ASSERT_NOT_NULL(wnd); 1510 1511 caption = "Hello"; 1512 1513 resp.rc = EOK; 1514 resp.window_set_caption_called = false; 1515 1516 rc = display_window_set_caption(wnd, caption); 1517 PCUT_ASSERT_INT_EQUALS(wnd->id, resp.set_caption_wnd_id); 1518 PCUT_ASSERT_TRUE(resp.window_set_caption_called); 1519 PCUT_ASSERT_ERRNO_VAL(resp.rc, rc); 1520 PCUT_ASSERT_INT_EQUALS(0, str_cmp(caption, resp.set_caption_caption)); 1521 1522 //free(resp.set_caption_caption); 1523 display_window_destroy(wnd); 1524 display_close(disp); 1525 rc = loc_service_unregister(srv, sid); 1526 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1527 loc_server_unregister(srv); 1015 1528 } 1016 1529 … … 1025 1538 test_response_t resp; 1026 1539 gfx_context_t *gc; 1027 1028 async_set_fallback_port_handler(test_display_conn, &resp); 1029 1030 // FIXME This causes this test to be non-reentrant! 1031 rc = loc_server_register(test_display_server); 1032 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1033 1034 rc = loc_service_register(test_display_svc, &sid); 1540 loc_srv_t *srv; 1541 1542 async_set_fallback_port_handler(test_display_conn, &resp); 1543 1544 // FIXME This causes this test to be non-reentrant! 1545 rc = loc_server_register(test_display_server, &srv); 1546 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1547 1548 rc = loc_service_register(srv, test_display_svc, &sid); 1035 1549 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1036 1550 … … 1063 1577 1064 1578 display_close(disp); 1065 rc = loc_service_unregister(sid); 1066 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1579 rc = loc_service_unregister(srv, sid); 1580 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1581 loc_server_unregister(srv); 1067 1582 } 1068 1583 … … 1078 1593 gfx_context_t *gc; 1079 1594 gfx_color_t *color; 1080 1081 async_set_fallback_port_handler(test_display_conn, &resp); 1082 1083 // FIXME This causes this test to be non-reentrant! 1084 rc = loc_server_register(test_display_server); 1085 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1086 1087 rc = loc_service_register(test_display_svc, &sid); 1595 loc_srv_t *srv; 1596 1597 async_set_fallback_port_handler(test_display_conn, &resp); 1598 1599 // FIXME This causes this test to be non-reentrant! 1600 rc = loc_server_register(test_display_server, &srv); 1601 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1602 1603 rc = loc_service_register(srv, test_display_svc, &sid); 1088 1604 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1089 1605 … … 1124 1640 1125 1641 display_close(disp); 1126 rc = loc_service_unregister(sid); 1127 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1642 rc = loc_service_unregister(srv, sid); 1643 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1644 loc_server_unregister(srv); 1128 1645 } 1129 1646 … … 1137 1654 display_window_t *wnd; 1138 1655 test_response_t resp; 1139 1140 async_set_fallback_port_handler(test_display_conn, &resp); 1141 1142 // FIXME This causes this test to be non-reentrant! 1143 rc = loc_server_register(test_display_server); 1144 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1145 1146 rc = loc_service_register(test_display_svc, &sid); 1656 loc_srv_t *srv; 1657 1658 async_set_fallback_port_handler(test_display_conn, &resp); 1659 1660 // FIXME This causes this test to be non-reentrant! 1661 rc = loc_server_register(test_display_server, &srv); 1662 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1663 1664 rc = loc_service_register(srv, test_display_svc, &sid); 1147 1665 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1148 1666 … … 1189 1707 display_close(disp); 1190 1708 1191 rc = loc_service_unregister(sid); 1192 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1709 rc = loc_service_unregister(srv, sid); 1710 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1711 loc_server_unregister(srv); 1193 1712 } 1194 1713 … … 1202 1721 display_window_t *wnd; 1203 1722 test_response_t resp; 1204 1205 async_set_fallback_port_handler(test_display_conn, &resp); 1206 1207 // FIXME This causes this test to be non-reentrant! 1208 rc = loc_server_register(test_display_server); 1209 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1210 1211 rc = loc_service_register(test_display_svc, &sid); 1723 loc_srv_t *srv; 1724 1725 async_set_fallback_port_handler(test_display_conn, &resp); 1726 1727 // FIXME This causes this test to be non-reentrant! 1728 rc = loc_server_register(test_display_server, &srv); 1729 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1730 1731 rc = loc_service_register(srv, test_display_svc, &sid); 1212 1732 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1213 1733 … … 1232 1752 resp.event_cnt = 1; 1233 1753 resp.event.etype = wev_focus; 1754 resp.event.ev.focus.nfocus = 42; 1234 1755 resp.wnd_id = wnd->id; 1235 1756 resp.focus_event_called = false; … … 1248 1769 PCUT_ASSERT_INT_EQUALS(resp.event.etype, 1249 1770 resp.revent.etype); 1771 PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus, 1772 resp.revent.ev.focus.nfocus); 1250 1773 1251 1774 rc = display_window_destroy(wnd); … … 1254 1777 display_close(disp); 1255 1778 1256 rc = loc_service_unregister(sid); 1257 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1779 rc = loc_service_unregister(srv, sid); 1780 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1781 loc_server_unregister(srv); 1258 1782 } 1259 1783 … … 1267 1791 display_window_t *wnd; 1268 1792 test_response_t resp; 1269 1270 async_set_fallback_port_handler(test_display_conn, &resp); 1271 1272 // FIXME This causes this test to be non-reentrant! 1273 rc = loc_server_register(test_display_server); 1274 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1275 1276 rc = loc_service_register(test_display_svc, &sid); 1793 loc_srv_t *srv; 1794 1795 async_set_fallback_port_handler(test_display_conn, &resp); 1796 1797 // FIXME This causes this test to be non-reentrant! 1798 rc = loc_server_register(test_display_server, &srv); 1799 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1800 1801 rc = loc_service_register(srv, test_display_svc, &sid); 1277 1802 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1278 1803 … … 1331 1856 display_close(disp); 1332 1857 1333 rc = loc_service_unregister(sid); 1334 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1858 rc = loc_service_unregister(srv, sid); 1859 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1860 loc_server_unregister(srv); 1335 1861 } 1336 1862 … … 1344 1870 display_window_t *wnd; 1345 1871 test_response_t resp; 1346 1347 async_set_fallback_port_handler(test_display_conn, &resp); 1348 1349 // FIXME This causes this test to be non-reentrant! 1350 rc = loc_server_register(test_display_server); 1351 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1352 1353 rc = loc_service_register(test_display_svc, &sid); 1872 loc_srv_t *srv; 1873 1874 async_set_fallback_port_handler(test_display_conn, &resp); 1875 1876 // FIXME This causes this test to be non-reentrant! 1877 rc = loc_server_register(test_display_server, &srv); 1878 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1879 1880 rc = loc_service_register(srv, test_display_svc, &sid); 1354 1881 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1355 1882 … … 1408 1935 display_close(disp); 1409 1936 1410 rc = loc_service_unregister(sid); 1411 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1937 rc = loc_service_unregister(srv, sid); 1938 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1939 loc_server_unregister(srv); 1412 1940 } 1413 1941 … … 1421 1949 display_window_t *wnd; 1422 1950 test_response_t resp; 1423 1424 async_set_fallback_port_handler(test_display_conn, &resp); 1425 1426 // FIXME This causes this test to be non-reentrant! 1427 rc = loc_server_register(test_display_server); 1428 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1429 1430 rc = loc_service_register(test_display_svc, &sid); 1951 loc_srv_t *srv; 1952 1953 async_set_fallback_port_handler(test_display_conn, &resp); 1954 1955 // FIXME This causes this test to be non-reentrant! 1956 rc = loc_server_register(test_display_server, &srv); 1957 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1958 1959 rc = loc_service_register(srv, test_display_svc, &sid); 1431 1960 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1432 1961 … … 1451 1980 resp.event_cnt = 1; 1452 1981 resp.event.etype = wev_unfocus; 1982 resp.event.ev.unfocus.nfocus = 42; 1453 1983 resp.wnd_id = wnd->id; 1454 1984 resp.unfocus_event_called = false; … … 1467 1997 PCUT_ASSERT_INT_EQUALS(resp.event.etype, 1468 1998 resp.revent.etype); 1999 PCUT_ASSERT_INT_EQUALS(resp.event.ev.focus.nfocus, 2000 resp.revent.ev.focus.nfocus); 1469 2001 1470 2002 rc = display_window_destroy(wnd); … … 1473 2005 display_close(disp); 1474 2006 1475 rc = loc_service_unregister(sid); 1476 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2007 rc = loc_service_unregister(srv, sid); 2008 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2009 loc_server_unregister(srv); 1477 2010 } 1478 2011 … … 1485 2018 display_info_t info; 1486 2019 test_response_t resp; 1487 1488 async_set_fallback_port_handler(test_display_conn, &resp); 1489 1490 // FIXME This causes this test to be non-reentrant! 1491 rc = loc_server_register(test_display_server); 1492 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1493 1494 rc = loc_service_register(test_display_svc, &sid); 2020 loc_srv_t *srv; 2021 2022 async_set_fallback_port_handler(test_display_conn, &resp); 2023 2024 // FIXME This causes this test to be non-reentrant! 2025 rc = loc_server_register(test_display_server, &srv); 2026 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2027 2028 rc = loc_service_register(srv, test_display_svc, &sid); 1495 2029 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1496 2030 … … 1507 2041 1508 2042 display_close(disp); 1509 rc = loc_service_unregister(sid); 1510 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2043 rc = loc_service_unregister(srv, sid); 2044 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2045 loc_server_unregister(srv); 1511 2046 } 1512 2047 … … 1519 2054 display_info_t info; 1520 2055 test_response_t resp; 1521 1522 async_set_fallback_port_handler(test_display_conn, &resp); 1523 1524 // FIXME This causes this test to be non-reentrant! 1525 rc = loc_server_register(test_display_server); 1526 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1527 1528 rc = loc_service_register(test_display_svc, &sid); 2056 loc_srv_t *srv; 2057 2058 async_set_fallback_port_handler(test_display_conn, &resp); 2059 2060 // FIXME This causes this test to be non-reentrant! 2061 rc = loc_server_register(test_display_server, &srv); 2062 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2063 2064 rc = loc_service_register(srv, test_display_svc, &sid); 1529 2065 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 1530 2066 … … 1549 2085 1550 2086 display_close(disp); 1551 rc = loc_service_unregister(sid); 1552 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2087 rc = loc_service_unregister(srv, sid); 2088 PCUT_ASSERT_ERRNO_VAL(EOK, rc); 2089 loc_server_unregister(srv); 1553 2090 } 1554 2091 … … 1612 2149 } 1613 2150 1614 static void test_focus_event(void *arg )2151 static void test_focus_event(void *arg, unsigned nfocus) 1615 2152 { 1616 2153 test_response_t *resp = (test_response_t *) arg; 1617 2154 1618 2155 resp->revent.etype = wev_focus; 2156 resp->revent.ev.focus.nfocus = nfocus; 1619 2157 1620 2158 fibril_mutex_lock(&resp->event_lock); … … 1650 2188 } 1651 2189 1652 static void test_unfocus_event(void *arg )2190 static void test_unfocus_event(void *arg, unsigned nfocus) 1653 2191 { 1654 2192 test_response_t *resp = (test_response_t *) arg; 1655 2193 1656 2194 resp->revent.etype = wev_unfocus; 2195 resp->revent.ev.unfocus.nfocus = nfocus; 1657 2196 1658 2197 fibril_mutex_lock(&resp->event_lock); … … 1670 2209 resp->create_rect = params->rect; 1671 2210 resp->create_min_size = params->min_size; 2211 resp->create_idev_id = params->idev_id; 1672 2212 if (resp->rc == EOK) 1673 2213 *rwnd_id = resp->wnd_id; … … 1686 2226 1687 2227 static errno_t test_window_move_req(void *arg, sysarg_t wnd_id, 1688 gfx_coord2_t *pos )2228 gfx_coord2_t *pos, sysarg_t pos_id) 1689 2229 { 1690 2230 test_response_t *resp = (test_response_t *) arg; … … 1693 2233 resp->move_req_wnd_id = wnd_id; 1694 2234 resp->move_req_pos = *pos; 2235 resp->move_req_pos_id = pos_id; 1695 2236 return resp->rc; 1696 2237 } … … 1719 2260 } 1720 2261 2262 static errno_t test_window_get_max_rect(void *arg, sysarg_t wnd_id, 2263 gfx_rect_t *rect) 2264 { 2265 test_response_t *resp = (test_response_t *) arg; 2266 2267 resp->window_get_max_rect_called = true; 2268 resp->get_max_rect_wnd_id = wnd_id; 2269 2270 if (resp->rc == EOK) 2271 *rect = resp->get_max_rect_rrect; 2272 2273 return resp->rc; 2274 } 2275 1721 2276 static errno_t test_window_resize_req(void *arg, sysarg_t wnd_id, 1722 display_wnd_rsztype_t rsztype, gfx_coord2_t *pos )2277 display_wnd_rsztype_t rsztype, gfx_coord2_t *pos, sysarg_t pos_id) 1723 2278 { 1724 2279 test_response_t *resp = (test_response_t *) arg; … … 1728 2283 resp->resize_req_wnd_id = wnd_id; 1729 2284 resp->resize_req_pos = *pos; 2285 resp->resize_req_pos_id = pos_id; 1730 2286 return resp->rc; 1731 2287 } … … 1743 2299 } 1744 2300 2301 static errno_t test_window_minimize(void *arg, sysarg_t wnd_id) 2302 { 2303 test_response_t *resp = (test_response_t *) arg; 2304 2305 resp->window_minimize_called = true; 2306 resp->resize_wnd_id = wnd_id; 2307 return resp->rc; 2308 } 2309 2310 static errno_t test_window_maximize(void *arg, sysarg_t wnd_id) 2311 { 2312 test_response_t *resp = (test_response_t *) arg; 2313 2314 resp->window_maximize_called = true; 2315 resp->resize_wnd_id = wnd_id; 2316 return resp->rc; 2317 } 2318 2319 static errno_t test_window_unmaximize(void *arg, sysarg_t wnd_id) 2320 { 2321 test_response_t *resp = (test_response_t *) arg; 2322 2323 resp->window_unmaximize_called = true; 2324 resp->resize_wnd_id = wnd_id; 2325 return resp->rc; 2326 } 2327 1745 2328 static errno_t test_window_set_cursor(void *arg, sysarg_t wnd_id, 1746 2329 display_stock_cursor_t cursor) … … 1751 2334 resp->set_cursor_wnd_id = wnd_id; 1752 2335 resp->set_cursor_cursor = cursor; 2336 2337 return resp->rc; 2338 } 2339 2340 static errno_t test_window_set_caption(void *arg, sysarg_t wnd_id, 2341 const char *caption) 2342 { 2343 test_response_t *resp = (test_response_t *) arg; 2344 2345 resp->window_set_caption_called = true; 2346 resp->set_caption_wnd_id = wnd_id; 2347 resp->set_caption_caption = str_dup(caption); 1753 2348 1754 2349 return resp->rc;
Note:
See TracChangeset
for help on using the changeset viewer.