test: Add tests for ds_tizen_scaler

Change-Id: I1eb8d0b69f236e77d46c3ef0fd737a337adfc387

diff --git a/packaging/libds-tizen.spec b/packaging/libds-tizen.spec
index 4ef8195..777384b 100644 (file)
--- a/packaging/libds-tizen.spec
+++ b/packaging/libds-tizen.spec
@@ -39,6 +39,7 @@ BuildRequires:  pkgconfig(cynara-session)
 BuildRequires:  pkgconfig(libsmack)
 BuildRequires:  pkgconfig(gmock)
 BuildRequires:  pkgconfig(scaler-server)
+BuildRequires:  pkgconfig(scaler-client)
 
 %description
 Wayland Compositor Library for Tizen
@@ -691,3 +692,4 @@ ninja -C builddir install
 %{_includedir}/libds-tizen/scaler.h
 %{_libdir}/pkgconfig/libds-tizen-scaler.pc
 %{_libdir}/libds-tizen-scaler.so
+%{_bindir}/libds-tizen-scaler-tests

diff --git a/tests/meson.build b/tests/meson.build
index e620eb0..b933ced 100644 (file)
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -344,3 +344,22 @@ executable('libds-tizen-screenshooter-tests',
   install_dir: libds_tizen_bindir,
   install : true
 )
+
+tc_scaler_files = [
+  'tc_main.cpp',
+  'tc_scaler.cpp',
+]
+
+executable('libds-tizen-scaler-tests',
+  [
+    tc_mock_files,
+    tc_scaler_files
+  ],
+  dependencies: [
+    deps_test_common,
+    deps_libds_tizen_scaler,
+    dependency('scaler-client', required: true),
+  ],
+  install_dir: libds_tizen_bindir,
+  install : true
+)

diff --git a/tests/mockclient.cpp b/tests/mockclient.cpp
index f9f9581..135c51c 100644 (file)
--- a/tests/mockclient.cpp
+++ b/tests/mockclient.cpp
@@ -28,6 +28,7 @@
 
 #include "mockclient.h"
 #include <iostream>
+#include <gtest/gtest.h>
 
 MockClient::MockClient()
 {
@@ -67,4 +68,47 @@ MockClient::~MockClient()
 void MockClient::RoundTrip()
 {
     wl_display_roundtrip(display);
-}
\ No newline at end of file
+}
+
+void MockClient::ExpectNoError()
+{
+    const struct wl_interface *interface;
+    uint32_t errcode;
+
+    this->RoundTrip();
+
+    int err = wl_display_get_error(this->display);
+
+    if (err != 0) {
+        errcode = wl_display_get_protocol_error(this->display, &interface,
+                NULL);
+    }
+
+    ASSERT_EQ(err, 0)
+        << "Expected no error, but got error(" << err << ") interface("
+        << interface->name << ") errcode(" << errcode << ")";
+
+}
+
+void MockClient::ExpectProtocolError(const struct wl_interface *intf,
+        uint32_t code)
+{
+    this->RoundTrip();
+
+    int err = wl_display_get_error(this->display);
+
+    ASSERT_NE(err, 0) << "Expected protocol error but nothing came";
+    ASSERT_EQ(err, EPROTO)
+        << "Expected protocol error but got local error";
+
+    const struct wl_interface *interface;
+    uint32_t errcode = wl_display_get_protocol_error(this->display,
+            &interface, NULL);
+
+    ASSERT_EQ(errcode, code)
+        << "Should get error code " << code << " but got " << errcode;
+
+    ASSERT_STREQ(intf->name, interface->name)
+        << "Should get interface '" << intf->name << "' but got '"
+        << interface->name << "'";
+}

diff --git a/tests/mockclient.h b/tests/mockclient.h
index 178b9bc..d3f4bf6 100644 (file)
--- a/tests/mockclient.h
+++ b/tests/mockclient.h
@@ -39,6 +39,8 @@ public:
     MockClient(const struct wl_registry_listener *registry_listener, void *data);
     virtual ~MockClient();
     void RoundTrip();
+    void ExpectNoError();
+    void ExpectProtocolError(const struct wl_interface *intf, uint32_t code);
 
 private:
     struct wl_display *display;

diff --git a/tests/mockcompositor.cpp b/tests/mockcompositor.cpp
index 62fc779..ef40f81 100644 (file)
--- a/tests/mockcompositor.cpp
+++ b/tests/mockcompositor.cpp
@@ -147,3 +147,8 @@ void MockCompositor::Process()
     std::lock_guard<std::mutex> lock(m);
     compositor->DispatchEvents();
 }
+
+struct wl_display *MockCompositor::GetWlDisplay()
+{
+    return this->compositor->display;
+}

diff --git a/tests/mockcompositor.h b/tests/mockcompositor.h
index 2b03f46..a0a8f87 100644 (file)
--- a/tests/mockcompositor.h
+++ b/tests/mockcompositor.h
@@ -65,6 +65,8 @@ public:
 
     void Process();
 
+    struct wl_display *GetWlDisplay();
+
 protected:
     Compositor *compositor;
 

diff --git a/tests/tc_scaler.cpp b/tests/tc_scaler.cpp
new file mode 100644 (file)
index 0000000..6a74df5
--- /dev/null
+++ b/tests/tc_scaler.cpp
@@ -0,0 +1,267 @@
+#include "tc_main.h"
+#include "mockclient.h"
+#include "mockcompositor.h"
+
+#include <cstring>
+#include <libds/log.h>
+#include <libds-tizen/scaler.h>
+#include <scaler-client-protocol.h>
+
+TEST(ScalerSimpleTest, CreateScaler)
+{
+    struct wl_display *display = wl_display_create();
+
+    struct ds_tizen_scaler *scaler = ds_tizen_scaler_create(display);
+    ASSERT_NE(scaler, nullptr);
+
+    wl_display_destroy(display);
+}
+
+class ScalerCompositor : public MockCompositor, public ::testing::Test
+{
+public:
+    ScalerCompositor() :
+        MockCompositor(&ScalerCompositor::SetUpComp, this)
+    {
+        /* We are only interested in test results. Let's silence libds log. */
+        ds_log_init(DS_SILENT, nullptr);
+    }
+
+    static void SetUpComp(void *data)
+    {
+        ScalerCompositor *comp = static_cast<ScalerCompositor*>(data);
+
+        struct ds_tizen_scaler *scaler =
+            ds_tizen_scaler_create(comp->GetWlDisplay());
+        ASSERT_NE(scaler, nullptr);
+    }
+};
+
+static void handle_global(void *data, struct wl_registry *registry,
+    uint32_t name, const char *interface, uint32_t version);
+static void handle_global_remove(void *data, struct wl_registry *registry,
+        uint32_t name);
+
+static const struct wl_registry_listener registry_listener = {
+    .global = handle_global,
+    .global_remove = handle_global_remove,
+};
+
+class MockScalerClient : public MockClient
+{
+public:
+    MockScalerClient() : MockClient(&registry_listener, this)
+    {
+        EXPECT_NE(this->compositor, nullptr);
+        EXPECT_NE(this->scaler, nullptr);
+
+        surface = wl_compositor_create_surface(this->compositor);
+        EXPECT_NE(this->surface, nullptr);
+    }
+
+    ~MockScalerClient() 
+    {
+        wl_surface_destroy(this->surface);
+        wl_scaler_destroy(this->scaler);
+        wl_compositor_destroy(this->compositor);
+    }
+
+    struct wl_compositor *compositor;
+    struct wl_scaler *scaler;
+    struct wl_surface *surface;
+};
+
+static void
+handle_global(void *data, struct wl_registry *registry,
+    uint32_t name, const char *interface, uint32_t version)
+{
+    MockScalerClient *client = static_cast<MockScalerClient*>(data);
+
+    if (strcmp(interface, "wl_compositor") == 0) {
+        client->compositor = static_cast<struct wl_compositor*>(
+                wl_registry_bind(registry, name, &wl_compositor_interface, 4));
+    } else if (strcmp(interface, "wl_scaler") == 0) {
+        client->scaler = static_cast<struct wl_scaler*>(
+                wl_registry_bind(registry, name, &wl_scaler_interface, 2));
+    }
+}
+
+static void
+handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
+{
+}
+
+TEST_F(ScalerCompositor, CreateViewport)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    client->ExpectNoError();
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+TEST_F(ScalerCompositor, CreateViewportTwice)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp[2];
+    vp[0] = wl_scaler_get_viewport(client->scaler, client->surface);
+    vp[1] = wl_scaler_get_viewport(client->scaler, client->surface);
+
+    client->ExpectProtocolError(&wl_scaler_interface,
+            WL_SCALER_ERROR_VIEWPORT_EXISTS);
+
+    wl_viewport_destroy(vp[0]);
+    wl_viewport_destroy(vp[1]);
+    delete client;
+}
+
+TEST_F(ScalerCompositor, SetSource)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    wl_viewport_set_source(vp,
+            wl_fixed_from_int(100), wl_fixed_from_int(100),
+            wl_fixed_from_int(100), wl_fixed_from_int(100));
+    wl_surface_commit(client->surface);
+
+    client->ExpectNoError();
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+TEST_F(ScalerCompositor, UnsetSource)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    wl_viewport_set_source(vp,
+            wl_fixed_from_int(-1.0), wl_fixed_from_int(-1.0),
+            wl_fixed_from_int(-1.0), wl_fixed_from_int(-1.0));
+    wl_surface_commit(client->surface);
+
+    client->ExpectNoError();
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+TEST_F(ScalerCompositor, SetDestination)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    wl_viewport_set_destination(vp, 100, 100);
+    wl_surface_commit(client->surface);
+
+    client->ExpectNoError();
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+TEST_F(ScalerCompositor, UnsetDestination)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    wl_viewport_set_destination(vp, -1, -1);
+    wl_surface_commit(client->surface);
+
+    client->ExpectNoError();
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+struct Box {
+    int x, y, width, height;
+};
+
+class ScalerCompositorBadSourceTest :
+    public ScalerCompositor,
+    public testing::WithParamInterface<Box>
+{
+};
+
+INSTANTIATE_TEST_SUITE_P(ScalerBadSourceParamTest,
+        ScalerCompositorBadSourceTest,
+        testing::Values(
+            Box{0, 0, 0, 0},
+            Box{0, 0, 0, 10},
+            Box{0, 0, 20, 0},
+            Box{0, 0, -20, 10},
+            Box{0, 0, 20, -10},
+            Box{0, 0, -20, -10}));
+
+TEST_P(ScalerCompositorBadSourceTest, SetBadSource)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    Box src = GetParam();
+    wl_viewport_set_source(vp,
+            wl_fixed_from_int(src.x), wl_fixed_from_int(src.y),
+            wl_fixed_from_int(src.width), wl_fixed_from_int(src.height));
+    wl_surface_commit(client->surface);
+
+    client->ExpectProtocolError(&wl_viewport_interface,
+            WL_VIEWPORT_ERROR_BAD_VALUE);
+
+    wl_viewport_destroy(vp);
+    delete client;
+}
+
+struct Size {
+    int width, height;
+};
+
+class ScalerCompositorBadDestinationTest :
+    public ScalerCompositor,
+    public testing::WithParamInterface<Size>
+{
+};
+
+INSTANTIATE_TEST_SUITE_P(ScalerBadDestinationParamTest,
+        ScalerCompositorBadDestinationTest,
+        testing::Values(
+            Size{0, 0},
+            Size{0, 10},
+            Size{20, 0},
+            Size{-20, 10},
+            Size{20, -10},
+            Size{-20, -10}));
+
+TEST_P(ScalerCompositorBadDestinationTest, SetBadDestination)
+{
+    MockScalerClient *client = new MockScalerClient();
+
+    struct wl_viewport *vp = wl_scaler_get_viewport(client->scaler,
+            client->surface);
+
+    Size dst = GetParam();
+    wl_viewport_set_destination(vp, dst.width, dst.height);
+    wl_surface_commit(client->surface);
+
+    client->ExpectProtocolError(&wl_viewport_interface,
+            WL_VIEWPORT_ERROR_BAD_VALUE);
+
+    wl_viewport_destroy(vp);
+    delete client;
+}