From: SooChan Lim <sc1.lim@samsung.com>
Date: Fri, 22 Jul 2022 02:15:18 +0000 (+0900)
Subject: add test cases for ds_tizen_renderer
X-Git-Tag: accepted/tizen/unified/20220808.135412~6
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d889e114a4fa9a32af3c04550f3b123c27a37d1a;p=platform%2Fcore%2Fuifw%2Flibds-tizen.git

add test cases for ds_tizen_renderer

Change-Id: I4f669d3fcf727c7109f0b8a81d14a12c55d3edbe
---

diff --git a/packaging/libds-tizen.spec b/packaging/libds-tizen.spec
index 8eddf79..38942c7 100644
--- a/packaging/libds-tizen.spec
+++ b/packaging/libds-tizen.spec
@@ -416,3 +416,4 @@ ninja -C builddir install
 %{_includedir}/libds-tizen/renderer.h
 %{_libdir}/pkgconfig/libds-tizen-renderer.pc
 %{_libdir}/libds-tizen-renderer.so
+%{_bindir}/libds-tizen-renderer-tests
diff --git a/tests/meson.build b/tests/meson.build
index 11af746..b375f18 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -125,3 +125,24 @@ executable('libds-tizen-memory-flusher-tests',
   install_dir: libds_tizen_bindir,
   install : true
 )
+
+## renderer tests
+tc_renderer_files = [
+  'tc_main.cpp',
+  'tc_renderer.cpp',
+]
+
+executable('libds-tizen-renderer-tests',
+  [
+    tc_mock_files,
+    tc_renderer_files
+  ],
+  dependencies: [
+    deps_test_common,
+    deps_libds_tizen_renderer,
+    dependency('libdrm', required: true),
+    dependency('tizen-extension-client', required: true),
+  ],
+  install_dir: libds_tizen_bindir,
+  install : true
+)
diff --git a/tests/tc_renderer.cpp b/tests/tc_renderer.cpp
new file mode 100644
index 0000000..078f782
--- /dev/null
+++ b/tests/tc_renderer.cpp
@@ -0,0 +1,382 @@
+#include "tc_main.h"
+#include "mockclient.h"
+#include "mockcompositor.h"
+#include <libds-tizen/renderer.h>
+#include <tizen-extension-client-protocol.h>
+
+#define TIZEN_RENDERER_VERSION 1
+
+class MockRendererCompositor : public MockCompositor
+{
+public:
+    MockRendererCompositor()
+        : MockCompositor(&MockRendererCompositor::TestSetup, this)
+    {
+        ds_inf("%s : this(%p)", __func__, this);
+
+        // initialize the flags to check
+        bSurfaceDestroyed = false;
+
+        bDestroyed = false;
+        bGetRendererSurface = false;
+        bDestroyRendererInfo = false;
+    }
+
+    ~MockRendererCompositor()
+    {
+        ds_inf("%s : this(%p)", __func__, this);
+    }
+
+    static void TestSetup(void *data)
+    {
+        MockRendererCompositor *mockComp =
+            static_cast<MockRendererCompositor *>(data);
+        Compositor *comp = mockComp->compositor;
+
+        ds_inf("%s: mockComp(%p)", __func__, mockComp);
+
+        // new surface listener
+        mockComp->mNewSurfaceListener.notify =
+            MockRendererCompositor::NewSurfaceCallback;
+        mockComp->mNewSurfaceListener.parent = mockComp;
+        ds_compositor_add_new_surface_listener(comp->compositor,
+                &mockComp->mNewSurfaceListener);
+
+        mockComp->mRenderer =
+            ds_tizen_renderer_create(comp->display);
+
+        // destroy listener
+        mockComp->mDestroyListener.notify =
+            MockRendererCompositor::DestroyCallback;
+        mockComp->mDestroyListener.parent = mockComp;
+        ds_tizen_renderer_add_destroy_listener(mockComp->mRenderer,
+            &mockComp->mDestroyListener);
+
+        // get_flusher_info listener
+        mockComp->mGetFlusherInfoListener.notify =
+            MockRendererCompositor::GetRendererSurfaceCallback;
+        mockComp->mGetFlusherInfoListener.parent = mockComp;
+        ds_tizen_renderer_add_get_renderer_surface_info_listener(
+            mockComp->mRenderer,
+            &mockComp->mGetFlusherInfoListener);
+    }
+
+    static void NewSurfaceCallback(struct wl_listener *listener, void *data)
+    {
+        MockRendererCompositor *mockComp =
+            reinterpret_cast<NewSurfaceListener *>(listener)->parent;
+        struct ds_surface *surface = static_cast<struct ds_surface *>(data);
+
+        ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
+
+        mockComp->mSurface = surface;
+
+        // del surface listener
+        mockComp->mDelSurfaceListener.notify =
+            MockRendererCompositor::DelSurfaceCallback;
+        mockComp->mDelSurfaceListener.parent = mockComp;
+        ds_surface_add_destroy_listener(surface,
+            &mockComp->mDelSurfaceListener);
+    }
+
+    static void DelSurfaceCallback(struct wl_listener *listener, void *data)
+    {
+        MockRendererCompositor *mockComp =
+            reinterpret_cast<DelSurfaceListener *>(listener)->parent;
+        struct ds_surface *surface = static_cast<struct ds_surface *>(data);
+
+        ds_inf("%s: mockComp(%p), surface(%p)", __func__, mockComp, surface);
+
+        if (ds_surface_get_wl_resource(mockComp->mSurface) ==
+            ds_surface_get_wl_resource(surface)) {
+            ds_inf("%s: surface is deleted.", __func__);
+            mockComp->bSurfaceDestroyed = true;
+        }
+    }
+
+    static void DestroyCallback(struct wl_listener *listener, void *data)
+    {
+        ds_inf("%s", __func__);
+
+        MockRendererCompositor *mockComp =
+            reinterpret_cast<DestroyListener *>(listener)->parent;
+
+        mockComp->bDestroyed = true;
+    }
+
+    static void GetRendererSurfaceCallback(struct wl_listener *listener,
+        void *data)
+    {
+        ds_inf("%s", __func__);
+
+        MockRendererCompositor *mockComp =
+            reinterpret_cast<GetFlusherInfoListener *>(listener)->parent;
+        struct ds_tizen_renderer_info *info =
+            static_cast<struct ds_tizen_renderer_info *>(data);
+
+        ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, info);
+
+        mockComp->bGetRendererSurface = true;
+
+        mockComp->mInfo = info;
+        mockComp->mSurface =
+            ds_tizen_renderer_info_get_surface(mockComp->mInfo);
+
+        // info destroy listener
+        mockComp->mRendererInfoDestroyListener.notify =
+            MockRendererCompositor::RendererInfoDestroyCallback;
+        mockComp->mRendererInfoDestroyListener.parent = mockComp;
+        ds_tizen_renderer_info_add_destroy_listener(mockComp->mInfo,
+            &mockComp->mRendererInfoDestroyListener);
+    }
+
+    static void RendererInfoDestroyCallback(struct wl_listener *listener,
+        void *data)
+    {
+        ds_inf("%s", __func__);
+
+        MockRendererCompositor *mockComp =
+            reinterpret_cast<FlusherInfoDestroyListener *>(listener)->parent;
+        struct ds_tizen_renderer_info *info =
+            static_cast<struct ds_tizen_renderer_info *>(data);
+
+        ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, info);
+
+        if (mockComp->mInfo == info) {
+            ds_inf("%s: info is deleted.", __func__);
+            mockComp->bDestroyRendererInfo = true;
+        }
+    }
+
+    void SendRendererInfoRedraw()
+    {
+        ds_inf("%s", __func__);
+
+        ds_tizen_renderer_info_send_redraw(mInfo);
+    }
+
+public:
+    bool bSurfaceDestroyed;
+    bool bDestroyed;
+    bool bGetRendererSurface;
+    bool bDestroyRendererInfo;
+
+private:
+    struct ds_tizen_renderer_info *mInfo;
+    struct ds_surface *mSurface;
+
+    struct NewSurfaceListener : ::wl_listener {
+        MockRendererCompositor *parent;
+    };
+    NewSurfaceListener mNewSurfaceListener;
+
+    struct DelSurfaceListener : ::wl_listener {
+        MockRendererCompositor *parent;
+    };
+    DelSurfaceListener mDelSurfaceListener;
+
+    struct ds_tizen_renderer *mRenderer;
+
+    struct DestroyListener : ::wl_listener {
+        MockRendererCompositor *parent;
+    };
+    DestroyListener mDestroyListener;
+
+    struct GetFlusherInfoListener : ::wl_listener {
+        MockRendererCompositor *parent;
+    };
+    GetFlusherInfoListener mGetFlusherInfoListener;
+
+    struct FlusherInfoDestroyListener : ::wl_listener {
+        MockRendererCompositor *parent;
+    };
+    FlusherInfoDestroyListener mRendererInfoDestroyListener;
+};
+
+class MockRendererClient : public MockClient
+{
+public:
+    MockRendererClient()
+        : bRedrawEvent(false),
+          compositor_res(nullptr),
+          renderer_res(nullptr)
+    {}
+    MockRendererClient(const struct wl_registry_listener *listener)
+        : MockClient(listener, this)
+    {
+        ds_inf("%s", __func__);
+
+        bRedrawEvent = false;
+    }
+    ~MockRendererClient()
+    {
+        ds_inf("%s", __func__);
+    }
+
+    void SetWlCompositor(struct wl_compositor *global_res)
+    {
+        ds_inf("%s", __func__);
+
+        compositor_res = global_res;
+    }
+
+    struct wl_compositor *GetWlCompositor()
+    {
+        ds_inf("%s", __func__);
+
+        return compositor_res;
+    }
+
+    void SetTizenRenderer(struct tizen_renderer *resource)
+    {
+        ds_inf("%s", __func__);
+
+        renderer_res = resource;
+    }
+
+    struct tizen_renderer *GetTizenRenderer()
+    {
+        ds_inf("%s", __func__);
+
+        return renderer_res;
+    }
+
+public:
+    bool bRedrawEvent;
+
+private:
+    struct wl_compositor *compositor_res;
+    struct tizen_renderer *renderer_res;
+};
+
+static void
+client_registry_cb_global(void *data, struct wl_registry *registry,
+    uint32_t name, const char *interface, uint32_t version)
+{
+    ds_inf("%s", __func__);
+
+    MockRendererClient *client = static_cast<MockRendererClient *>(data);
+    struct wl_compositor *compositor_res;
+    struct tizen_renderer *renderer_res;
+
+    if (!strcmp(interface, "wl_compositor")) {
+        compositor_res = (struct wl_compositor *)wl_registry_bind(registry,
+            name, &wl_compositor_interface, 1);
+        if (compositor_res == nullptr) {
+            ds_err("wl_registry_bind() failed. wl_compositor resource.");
+            return;
+        }
+        client->SetWlCompositor(compositor_res);
+    } else if (!strcmp(interface, "tizen_renderer")) {
+        renderer_res = (struct tizen_renderer *)wl_registry_bind(registry,
+            name, &tizen_renderer_interface, TIZEN_RENDERER_VERSION);
+        if (renderer_res == nullptr) {
+            ds_err("wl_registry_bind() failed. tizen_renderer resource.");
+            return;
+        }
+        client->SetTizenRenderer(renderer_res);
+    }
+}
+
+static void
+client_registry_cb_global_remove(void *data, struct wl_registry *registry,
+    uint32_t name)
+{
+    ds_inf("%s", __func__);
+
+    MockRendererClient *client = static_cast<MockRendererClient *>(data);
+    struct wl_compositor *compositor_res = client->GetWlCompositor();
+    struct tizen_renderer *renderer_res = client->GetTizenRenderer();
+
+    tizen_renderer_destroy(renderer_res);
+    wl_compositor_destroy(compositor_res);
+}
+
+static const struct wl_registry_listener registry_listener = {
+    .global = client_registry_cb_global,
+    .global_remove = client_registry_cb_global_remove
+};
+
+static void
+client_tizen_renderer_surface_cb_redraw_request(void *data,
+    struct tizen_renderer_surface *renderer_surface_res)
+{
+    ds_inf("%s", __func__);
+
+    MockRendererClient *client = static_cast<MockRendererClient *>(data);
+
+    client->bRedrawEvent = true;
+}
+
+static const struct
+tizen_renderer_surface_listener renderer_surface_cb_listener = {
+    .redraw_request = client_tizen_renderer_surface_cb_redraw_request,
+};
+
+class RendererTest : public ::testing::Test
+{
+public:
+    void SetUp(void) override;
+    void TearDown(void) override;
+
+    MockRendererCompositor *comp;
+    MockRendererClient *client;
+    struct wl_compositor *compositor_res;
+    struct tizen_renderer *renderer_res;
+    struct wl_surface *surface_res;
+    struct tizen_renderer_surface *renderer_surface_res;
+};
+
+void
+RendererTest::SetUp(void)
+{
+    //ds_log_init(DS_DBG, NULL);
+
+    ds_inf("%s", __func__);
+
+    comp = new MockRendererCompositor();
+    client = new MockRendererClient(&registry_listener);
+    compositor_res = client->GetWlCompositor();
+    renderer_res = client->GetTizenRenderer();
+    surface_res = wl_compositor_create_surface(compositor_res);
+
+    renderer_surface_res =
+        tizen_renderer_get_renderer_surface(renderer_res, surface_res);
+
+    tizen_renderer_surface_add_listener(renderer_surface_res,
+        &renderer_surface_cb_listener, client);
+
+    client->RoundTrip();
+}
+
+void
+RendererTest::TearDown(void)
+{
+    ds_inf("%s", __func__);
+
+    tizen_renderer_surface_destroy(renderer_surface_res);
+    client->RoundTrip();
+    EXPECT_TRUE(comp->bDestroyRendererInfo);
+
+    wl_surface_destroy(surface_res);
+    client->RoundTrip();
+    EXPECT_TRUE(comp->bSurfaceDestroyed);
+
+    delete client;
+    delete comp;
+}
+
+TEST_F(RendererTest, Create_P)
+{
+    EXPECT_TRUE(true);
+    EXPECT_TRUE(comp->bGetRendererSurface);
+}
+
+TEST_F(RendererTest, Ev_TizenRendererSurfaceRedraw)
+{
+    comp->SendRendererInfoRedraw();
+    comp->Process();
+
+    client->RoundTrip();
+    EXPECT_TRUE(client->bRedrawEvent);
+}