unittests: make a MockCompositor creator with global interface parameter

Change-Id: If48c588569e5668d7e18356351538e2c2eacdb88

diff --git a/unittests/mockcompositor.cpp b/unittests/mockcompositor.cpp
index 9ed4e39..c9e2368 100644 (file)
--- a/unittests/mockcompositor.cpp
+++ b/unittests/mockcompositor.cpp
@@ -34,10 +34,166 @@ logger_func(void *user_data, enum wl_protocol_logger_type type,
                const struct wl_protocol_logger_message *message)
 {
        //Compositor *c = static_cast<Compositor *>(user_data);
-
+#if 0
        std::cout << "res:" << wl_resource_get_class(message->resource) << " "
                                << "op:" << message->message_opcode << " "
                                << "name:" << message->message->name << "\n";
+#endif
+}
+
+static void
+_compositor_wl_surface_cb_destroy(struct wl_client *client, struct wl_resource *surface_res)
+{
+   wl_resource_destroy(surface_res);
+}
+
+static void
+_compositor_wl_surface_cb_attach(struct wl_client *client,
+                                               struct wl_resource *surface_res,
+                                               struct wl_resource *buffer_res,
+                                               int32_t x,
+                                               int32_t y)
+{
+}
+
+static void
+_compositor_wl_surface_cb_damage(struct wl_client *client,
+                                               struct wl_resource *surface_res,
+                                               int32_t x,
+                                               int32_t y,
+                                               int32_t w,
+                                               int32_t h)
+{
+}
+
+static void
+_compositor_surface_cb_frame(struct wl_client *client,
+                                               struct wl_resource *surface_res,
+                                               uint32_t callback)
+{
+}
+
+static void
+_compositor_surface_cb_opaque_region_set(struct wl_client *client,
+                                                                struct wl_resource *surface_res,
+                                                                struct wl_resource *region_res)
+{
+}
+
+static void
+_compositor_surface_cb_input_region_set(struct wl_client *client,
+                                                               struct wl_resource *surface_res,
+                                                               struct wl_resource *region_res)
+{
+}
+
+static void
+_compositor_surface_cb_commit(struct wl_client *client,
+                                                struct wl_resource *surface_res)
+{
+}
+
+static void
+_compositor_surface_cb_buffer_transform_set(struct wl_client *client,
+                                                                       struct wl_resource *surface_res,
+                                                                       int32_t transform)
+{
+}
+
+static void
+_compositor_surface_cb_buffer_scale_set(struct wl_client *client,
+                                                               struct wl_resource *surface_res,
+                                                               int32_t scale)
+{
+}
+
+static void
+_compositor_surface_cb_damage_buffer(struct wl_client *client,
+                                                               struct wl_resource *surface_res,
+                                                               int32_t x,
+                                                               int32_t y,
+                                                               int32_t w,
+                                                               int32_t h)
+{
+}
+
+static const struct wl_surface_interface _compositor_wl_surface_interface =
+{
+       _compositor_wl_surface_cb_destroy,
+       _compositor_wl_surface_cb_attach,
+       _compositor_wl_surface_cb_damage,
+       _compositor_surface_cb_frame,
+       _compositor_surface_cb_opaque_region_set,
+       _compositor_surface_cb_input_region_set,
+       _compositor_surface_cb_commit,
+       _compositor_surface_cb_buffer_transform_set,
+       _compositor_surface_cb_buffer_scale_set,
+       _compositor_surface_cb_damage_buffer,
+};
+
+static void
+_compositor_wl_surface_destroy(struct wl_resource *surface_res)
+{
+}
+
+static void
+_compositor_wl_compositor_cb_surface_create(struct wl_client *client,
+                                                                               struct wl_resource *compositor_res,
+                                                                               uint32_t id)
+{
+       struct wl_resource *surface_res;
+
+       surface_res = wl_resource_create(client,
+                                                               &wl_surface_interface,
+                                                               wl_resource_get_version(compositor_res),
+                                                               id);
+       if (surface_res == nullptr) {
+               std::cout << "fail to create wl_surface resource.\n";
+                wl_client_post_no_memory(client);
+               return;
+       }
+
+       /* set implementation on resource */
+       wl_resource_set_implementation(surface_res,
+                                                               &_compositor_wl_surface_interface,
+                                                               NULL,
+                                                               _compositor_wl_surface_destroy);
+}
+
+static void
+_compositor_wl_compositor_cb_region_create(struct wl_client *client,
+                                                                       struct wl_resource *compositor_res,
+                                                                       uint32_t id)
+{
+}
+
+static const struct wl_compositor_interface _compositor_wl_compositor_interface =
+{
+   _compositor_wl_compositor_cb_surface_create,
+   _compositor_wl_compositor_cb_region_create
+};
+
+static void
+_compositor_wl_compositor_cb_unbind(struct wl_resource *compositor_res)
+{
+}
+
+static void
+_compositor_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
+{
+       struct wl_resource *compositor_res;
+
+       compositor_res = wl_resource_create(client, &wl_compositor_interface, version, id);
+       if (compositor_res == nullptr) {
+               std::cout << "fail to create wl_compositor resource.\n";
+                wl_client_post_no_memory(client);
+               return;
+       }
+
+       wl_resource_set_implementation(compositor_res,
+                                                               &_compositor_wl_compositor_interface,
+                                                               NULL,
+                                                               _compositor_wl_compositor_cb_unbind);
 }
 
 Compositor::Compositor ()
@@ -50,6 +206,32 @@ Compositor::Compositor ()
                std::cout << "fail to add socket\n";
 }
 
+Compositor::Compositor(const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind)
+       : display(wl_display_create()),
+         loop(wl_display_get_event_loop(display)),
+         logger(wl_display_add_protocol_logger(display, logger_func, this))
+{
+       int ret;
+       struct wl_global *global;
+       struct wl_global *compositor_global;
+
+       ret = wl_display_add_socket(display, "test-wl-extension-socket");
+       if (ret != 0)
+               std::cout << "fail to add socket\n";
+
+       global = wl_global_create(display, interface, version, data, bind);
+       if (global == nullptr)
+               std::cout << "fail to create global\n";
+
+       compositor_global = wl_global_create(display,
+                                                                       &wl_compositor_interface,
+                                                                       4,
+                                                                       NULL,
+                                                                       _compositor_cb_bind);
+       if (compositor_global == nullptr)
+               std::cout << "fail to create compositor_global\n";
+}
+
 Compositor::~Compositor ()
 {
        wl_list *clients = wl_display_get_client_list(display);
@@ -96,6 +278,31 @@ MockCompositor::MockCompositor()
        }
 }
 
+MockCompositor::MockCompositor(const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind)
+       : compositor(nullptr)
+{
+       th = std::thread([this, interface, version, data, bind](){
+               Compositor c(interface, version, data, bind);
+               compositor = &c;
+
+               // mockcompositor is ready
+               ready = true;
+               cv.notify_one();
+
+               while (alive) {
+                       // mockcompositor process the events in every 40 milliseconds
+                       std::this_thread::sleep_for(std::chrono::milliseconds(40));
+                       Process();
+               }
+       });
+
+       // wait until the child thread(mockcompositor) is ready
+       {
+               std::unique_lock<std::mutex> lock(m);
+               cv.wait(lock, [this]{return ready;});
+       }
+}
+
 MockCompositor::~MockCompositor() {
        // finish the child thread(mockcompositor).
        alive = false;

diff --git a/unittests/mockcompositor.h b/unittests/mockcompositor.h
index b75212e..72ecb9c 100644 (file)
--- a/unittests/mockcompositor.h
+++ b/unittests/mockcompositor.h
@@ -39,6 +39,7 @@ class Compositor
 {
 public:
        Compositor();
+       Compositor(const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind);
        ~Compositor();
        void DispatchEvents();
 
@@ -52,6 +53,7 @@ class MockCompositor
 {
 public:
        MockCompositor();
+       MockCompositor(const struct wl_interface *interface, int version, void *data, wl_global_bind_func_t bind);
        virtual ~MockCompositor();
 
        void Process();