Changeset 4912dd59 in mainline

Timestamp:

2020-05-19T10:21:12Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

4c4d6142

Parents:

4d8002d

git-author:

Jiri Svoboda <jiri@…> (2020-05-18 18:17:47)

git-committer:

Jiri Svoboda <jiri@…> (2020-05-19 10:21:12)

Message:

Actually fill in fake cursor unit tests (paint, get_rect)

Fixed ds_cursor_paint() to work without GC (fixes post_ptd_event_wnd_switch
test) and fixed ds_cursor_paint() to render bitmap also when called
for the first time (found by the unit test).

Location:

uspace/srv/hid/display

Files:

• cursor.c (modified) (2 diffs)
• ddev.c (modified) (2 diffs)
• ddev.h (modified) (1 diff)
• meson.build (modified) (1 diff)
• test/cursor.c (modified) (5 diffs)
• test/main.c (modified) (1 diff)

uspace/srv/hid/display/cursor.c

@@ -104 +104 @@
 
         dgc = ds_display_get_gc(cursor->display); // XXX
+        if (dgc == NULL)
+                return EOK;
 
         gfx_bitmap_params_init(&bparams);
@@ -144 +146 @@
                         }
                 }
-
-                return EOK;
         }
 

uspace/srv/hid/display/ddev.c

@@ -42 +42 @@
 #include "display.h"
 #include "ddev.h"
+
+/** Create display device object.
+ *
+ * @param display Parent display
+ * @param dd Display device
+ * @param info Display device info
+ * @param svc_id Display device service ID
+ * @param svc_name Display device service name
+ * @param gc Display device GC
+ * @param rddev Place to store pointer to new display device.
+ * @return EOK on success, ENOMEM if out of memory
+ */
+errno_t ds_ddev_create(ds_display_t *display, ddev_t *dd,
+    ddev_info_t *info, char *svc_name, service_id_t svc_id,
+    gfx_context_t *gc, ds_ddev_t **rddev)
+{
+        ds_ddev_t *ddev;
+
+        ddev = calloc(1, sizeof(ds_ddev_t));
+        if (ddev == NULL)
+                return ENOMEM;
+
+        ddev->svc_name = svc_name;
+        ddev->svc_id = svc_id;
+        ddev->dd = dd;
+        ddev->gc = gc;
+        ddev->info = *info;
+
+        ds_display_add_ddev(display, ddev);
+
+        *rddev = ddev;
+        return EOK;
+}
 
 /** Open display device.
@@ -95 +128 @@
         }
 
-        ddev = calloc(1, sizeof(ds_ddev_t));
-        if (ddev == NULL) {
+        rc = ds_ddev_create(display, dd, &info, name, svc_id, gc, &ddev);
+        if (rc != EOK) {
                 free(name);
                 ddev_close(dd);
-                return ENOMEM;
+                gfx_context_delete(gc);
+                return rc;
         }
-
-        ddev->svc_name = name;
-        ddev->svc_id = svc_id;
-        ddev->dd = dd;
-        ddev->gc = gc;
-        ddev->info = info;
-
-        ds_display_add_ddev(display, ddev);
 
         rc = ds_display_paint_bg(display, NULL);

uspace/srv/hid/display/ddev.h

@@ -42 +42 @@
 #include "types/display/display.h"
 
+extern errno_t ds_ddev_create(ds_display_t *, ddev_t *, ddev_info_t *,
+    char *, service_id_t, gfx_context_t *, ds_ddev_t **);
 extern errno_t ds_ddev_open(ds_display_t *, service_id_t, ds_ddev_t **);
 extern void ds_ddev_close(ds_ddev_t *);

uspace/srv/hid/display/meson.build

@@ -47 +47 @@
         'cursimg.c',
         'cursor.c',
+        'ddev.c',
         'display.c',
         'seat.c',

uspace/srv/hid/display/test/cursor.c

@@ -28 +28 @@
 
 #include <errno.h>
+#include <gfx/context.h>
+#include <stdbool.h>
 #include <pcut/pcut.h>
 
 #include "../cursor.h"
 #include "../cursimg.h"
+#include "../ddev.h"
 #include "../display.h"
+#include "../display.h"
 
 PCUT_INIT;
 
 PCUT_TEST_SUITE(cursor);
+
+static errno_t dummy_bitmap_create(void *, gfx_bitmap_params_t *,
+    gfx_bitmap_alloc_t *, void **);
+static errno_t dummy_bitmap_destroy(void *);
+static errno_t dummy_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
+static errno_t dummy_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
+
+static gfx_context_ops_t dummy_ops = {
+        .bitmap_create = dummy_bitmap_create,
+        .bitmap_destroy = dummy_bitmap_destroy,
+        .bitmap_render = dummy_bitmap_render,
+        .bitmap_get_alloc = dummy_bitmap_get_alloc
+};
+
+
+typedef struct {
+        bool render_called;
+} test_response_t;
+
+typedef struct {
+        test_response_t *resp;
+        gfx_bitmap_alloc_t alloc;
+} dummy_bitmap_t;
 
 /** Test ds_cursor_create(), ds_cursor_destroy(). */
@@ -59 +86 @@
 PCUT_TEST(cursor_paint)
 {
+        gfx_context_t *gc;
         ds_display_t *disp;
         ds_cursor_t *cursor;
+        ds_ddev_t *ddev;
+        ddev_info_t ddinfo;
+        gfx_coord2_t pos;
+        test_response_t resp;
         errno_t rc;
 
-        rc = ds_display_create(NULL, &disp);
+        rc = gfx_context_new(&dummy_ops, &resp, &gc);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = ds_display_create(gc, &disp);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        ddev_info_init(&ddinfo);
+
+        rc = ds_ddev_create(disp, NULL, &ddinfo, NULL, 0, gc, &ddev);
         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 
@@ -70 +110 @@
         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 
+        resp.render_called = false;
+
+        pos.x = 0;
+        pos.y = 0;
+        ds_cursor_paint(cursor, &pos);
+
+        PCUT_ASSERT_TRUE(resp.render_called);
+
         ds_cursor_destroy(cursor);
         ds_display_destroy(disp);
@@ -79 +127 @@
         ds_display_t *disp;
         ds_cursor_t *cursor;
+        gfx_coord2_t pos1, pos2;
+        gfx_rect_t rect1, rect2;
         errno_t rc;
 
@@ -88 +138 @@
         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
 
+        pos1.x = 10;
+        pos1.y = 11;
+
+        pos2.x = 22;
+        pos2.y = 23;
+
+        ds_cursor_get_rect(cursor, &pos1, &rect1);
+        ds_cursor_get_rect(cursor, &pos2, &rect2);
+
+        PCUT_ASSERT_FALSE(gfx_rect_is_empty(&rect1));
+        PCUT_ASSERT_FALSE(gfx_rect_is_empty(&rect2));
+
+        PCUT_ASSERT_INT_EQUALS(pos2.x - pos1.x, rect2.p0.x - rect1.p0.x);
+        PCUT_ASSERT_INT_EQUALS(pos2.y - pos1.y, rect2.p0.y - rect1.p0.y);
+        PCUT_ASSERT_INT_EQUALS(pos2.x - pos1.x, rect2.p1.x - rect1.p1.x);
+        PCUT_ASSERT_INT_EQUALS(pos2.y - pos1.y, rect2.p1.y - rect1.p1.y);
+
         ds_cursor_destroy(cursor);
         ds_display_destroy(disp);
 }
 
+static errno_t dummy_bitmap_create(void *arg, gfx_bitmap_params_t *params,
+    gfx_bitmap_alloc_t *alloc, void **rbm)
+{
+        test_response_t *resp = (test_response_t *) arg;
+        dummy_bitmap_t *bm;
+        gfx_coord2_t dims;
+
+        gfx_rect_dims(&params->rect, &dims);
+        bm = calloc(1, sizeof(dummy_bitmap_t));
+        if (bm == NULL)
+                return ENOMEM;
+
+        bm->resp = resp;
+        bm->alloc.pitch = dims.x * sizeof(uint32_t);
+        bm->alloc.off0 = 0;
+
+        bm->alloc.pixels = malloc(bm->alloc.pitch * dims.y * sizeof(uint32_t));
+        if (bm->alloc.pixels == NULL) {
+                free(bm);
+                return ENOMEM;
+        }
+
+        *rbm = (void *) bm;
+        return EOK;
+}
+
+static errno_t dummy_bitmap_destroy(void *arg)
+{
+        dummy_bitmap_t *bm = (dummy_bitmap_t *) arg;
+
+        free(bm);
+        return EOK;
+}
+
+static errno_t dummy_bitmap_render(void *arg, gfx_rect_t *rect,
+    gfx_coord2_t *dpos)
+{
+        dummy_bitmap_t *bm = (dummy_bitmap_t *) arg;
+
+        bm->resp->render_called = true;
+        return EOK;
+}
+
+static errno_t dummy_bitmap_get_alloc(void *arg, gfx_bitmap_alloc_t *alloc)
+{
+        dummy_bitmap_t *bm = (dummy_bitmap_t *) arg;
+
+        *alloc = bm->alloc;
+        return EOK;
+}
+
+
 PCUT_EXPORT(cursor);

uspace/srv/hid/display/test/main.c

@@ -32 +32 @@
 
 PCUT_IMPORT(client);
+PCUT_IMPORT(cursor);
 PCUT_IMPORT(display);
 PCUT_IMPORT(window);