DSWindowManager: add TCs

Change-Id: If005e3d9b2b5151fca6d5b30af68aa00e28f5fc8

diff --git a/tests/DSWindowManager-test.cpp b/tests/DSWindowManager-test.cpp
index cc3de04..43f5d02 100644 (file)
--- a/tests/DSWindowManager-test.cpp
+++ b/tests/DSWindowManager-test.cpp
@@ -31,28 +31,25 @@
 
 using namespace display_server;
 
-DSWindowManager* g_winMgr = nullptr;
-
 class DSWindowManagerTest : public ::testing::Test
 {
 public:
-        void SetUp(void) override
-        {
-                char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR");
-                setenv("XDG_RUNTIME_DIR", xdir, 1);
-               g_winMgr = DSWindowManager::getInstance();
-        }
-        void TearDown(void) override
-        {
-               DSWindowManager::releaseInstance();
-               g_winMgr = nullptr;
-                unsetenv("XDG_RUNTIME_DIR");
-        }
+       void SetUp(void) override
+       {
+               char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR");
+               setenv("XDG_RUNTIME_DIR", xdir, 1);
+       }
+       void TearDown(void) override
+       {
+               unsetenv("XDG_RUNTIME_DIR");
+       }
 };
 
 TEST_F(DSWindowManagerTest, GetWindowManager)
 {
-       EXPECT_TRUE(g_winMgr != nullptr);
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+       DSWindowManager::releaseInstance();
 }
 
 TEST_F(DSWindowManagerTest, RegisterWindow)
@@ -60,7 +57,8 @@ TEST_F(DSWindowManagerTest, RegisterWindow)
        bool ret = false;
        DSZone *foundZone = nullptr;
 
-       EXPECT_TRUE(g_winMgr != nullptr);
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
 
        auto zone = std::make_shared<DSZone>();
        EXPECT_TRUE(zone != nullptr);
@@ -68,19 +66,21 @@ TEST_F(DSWindowManagerTest, RegisterWindow)
        auto window = std::make_shared<DSWindow>();
        EXPECT_TRUE(window != nullptr);
 
-       foundZone = g_winMgr->getZone(window.get());
+       foundZone = winMgr->getZone(window.get());
        EXPECT_TRUE(foundZone == nullptr);
 
-       ret = g_winMgr->registerWindow(zone.get(), window.get());
+       ret = winMgr->registerWindow(zone.get(), window.get());
        EXPECT_TRUE(ret == true);
 
-       foundZone = g_winMgr->getZone(window.get());
+       foundZone = winMgr->getZone(window.get());
        EXPECT_TRUE(foundZone == zone.get());
 
-       g_winMgr->unregisterWindow(zone.get(), window.get());
+       winMgr->unregisterWindow(zone.get(), window.get());
 
-       foundZone = g_winMgr->getZone(window.get());
+       foundZone = winMgr->getZone(window.get());
        EXPECT_TRUE(foundZone == nullptr);
+
+       DSWindowManager::releaseInstance();
 }
 
 TEST_F(DSWindowManagerTest, RegisterSurface)
@@ -88,7 +88,8 @@ TEST_F(DSWindowManagerTest, RegisterSurface)
        bool ret = false;
        DSZone *foundZone = nullptr;
 
-       EXPECT_TRUE(g_winMgr != nullptr);
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
 
        auto zone = std::make_shared<DSZone>();
        EXPECT_TRUE(zone != nullptr);
@@ -96,19 +97,348 @@ TEST_F(DSWindowManagerTest, RegisterSurface)
        auto surface = std::make_shared<DSWaylandSurface>();
        EXPECT_TRUE(surface != nullptr);
 
-       foundZone = g_winMgr->getZone(surface.get());
+       foundZone = winMgr->getZone(surface.get());
        EXPECT_TRUE(foundZone == nullptr);
 
-       ret = g_winMgr->registerSurface(zone.get(), surface.get());
+       ret = winMgr->registerSurface(zone.get(), surface.get());
        EXPECT_TRUE(ret == true);
 
-       foundZone = g_winMgr->getZone(surface.get());
+       foundZone = winMgr->getZone(surface.get());
        EXPECT_TRUE(foundZone == zone.get());
 
-       g_winMgr->unregisterSurface(zone.get(), surface.get());
+       winMgr->unregisterSurface(zone.get(), surface.get());
 
-       foundZone = g_winMgr->getZone(surface.get());
+       foundZone = winMgr->getZone(surface.get());
        EXPECT_TRUE(foundZone == nullptr);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, ParentTest_P1)
+{
+       bool ret = false;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       auto surface2 = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface2 != nullptr);
+
+       zone->testCreateWindow(surface);
+       zone->testCreateWindow(surface2);
+
+       ret = winMgr->registerSurface(zone.get(), surface.get());
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->registerSurface(zone.get(), surface2.get());
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->setWindowParent(surface.get(), nullptr);
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->setWindowParent(surface.get(), surface2.get());
+       EXPECT_TRUE(ret == true);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, ParentTest_N1)
+{
+       bool ret = false;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto zone2 = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone2 != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       auto surface2 = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface2 != nullptr);
+
+       // Not registered to DSZone
+       ret = winMgr->setWindowParent(surface.get(), surface2.get());
+       EXPECT_TRUE(ret == false);
+
+       winMgr->registerSurface(zone.get(), surface.get());
+       winMgr->registerSurface(zone2.get(), surface2.get());
+
+       // Not SAME DSZone
+       ret = winMgr->setWindowParent(surface.get(), surface2.get());
+       EXPECT_TRUE(ret == false);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, PropertyTest)
+{
+       bool ret = false;
+       DSWindow *window = nullptr;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       DSWaylandSurface *surface_ptr = surface.get();
+       EXPECT_TRUE(surface_ptr != nullptr);
+
+       zone->testCreateWindow(surface);
+
+       ret = winMgr->registerSurface(zone.get(), surface_ptr);
+       EXPECT_TRUE(ret == true);
+
+       std::list<std::shared_ptr<DSWindow>> winList = zone->getWindowList();
+       for (auto w : winList)
+       {
+               if (w->surface() == surface_ptr)
+               {
+                       window = w.get();
+               }
+       }
+       EXPECT_TRUE(window != nullptr);
+
+       winMgr->setWindowTitle(surface_ptr, "test");
+       const std::string str = window->getTitle();
+       EXPECT_TRUE(str == "test");
+
+       winMgr->setWindowType(surface_ptr, 3);
+
+       winMgr->setWindowAllowUserGeometry(surface_ptr, true);
+       winMgr->setWindowGeometry(surface_ptr, 100, 200, 320, 480);
+       stGeometry geo = winMgr->getWindowGeometry(surface_ptr);
+       EXPECT_TRUE(geo.x == 100);
+       EXPECT_TRUE(geo.y == 200);
+       EXPECT_TRUE(geo.w == 320);
+       EXPECT_TRUE(geo.h == 480);
+
+       winMgr->setWindowPosition(surface_ptr, 50, 100);
+       geo = winMgr->getWindowGeometry(surface_ptr);
+       EXPECT_TRUE(geo.x == 50);
+       EXPECT_TRUE(geo.y == 100);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, AuxHintsTest)
+{
+       bool ret = false;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       DSWaylandSurface *surface_ptr = surface.get();
+       EXPECT_TRUE(surface_ptr != nullptr);
+
+       zone->testCreateWindow(surface);
+
+       ret = winMgr->registerSurface(zone.get(), surface_ptr);
+       EXPECT_TRUE(ret == true);
+
+       std::list<std::string> auxList = winMgr->getWindowSupportedAuxHints(surface_ptr);
+       EXPECT_TRUE(auxList.size() > 0);
+
+       winMgr->addWindowAuxHint(surface_ptr, 1, "wm.policy.win.user.geometry", "1");
+       winMgr->setWindowGeometry(surface_ptr, 100, 200, 320, 480);
+       stGeometry geo = winMgr->getWindowGeometry(surface_ptr);
+       EXPECT_TRUE(geo.x == 100);
+       EXPECT_TRUE(geo.y == 200);
+       EXPECT_TRUE(geo.w == 320);
+       EXPECT_TRUE(geo.h == 480);
+
+       winMgr->changeWindowAuxHint(surface_ptr, 1, "0");
+       geo = winMgr->getWindowGeometry(surface_ptr);
+       EXPECT_TRUE(geo.x == 0);
+       EXPECT_TRUE(geo.y == 0);
+
+       winMgr->removeWindowAuxHint(surface_ptr, 1);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, StackTest)
+{
+       bool ret = false;
+       DSWindow *resultWindow[3];
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface0 = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface0 != nullptr);
+       DSWaylandSurface *surface_ptr0 = surface0.get();
+       EXPECT_TRUE(surface_ptr0 != nullptr);
+
+       auto surface1 = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface1 != nullptr);
+       DSWaylandSurface *surface_ptr1 = surface1.get();
+       EXPECT_TRUE(surface_ptr1 != nullptr);
+
+       auto surface2 = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface2 != nullptr);
+       DSWaylandSurface *surface_ptr2 = surface2.get();
+       EXPECT_TRUE(surface_ptr2 != nullptr);
+
+       zone->testCreateWindow(surface0);
+       zone->testCreateWindow(surface1);
+       zone->testCreateWindow(surface2);
+
+       ret = winMgr->registerSurface(zone.get(), surface_ptr0);
+       EXPECT_TRUE(ret == true);
+       ret = winMgr->registerSurface(zone.get(), surface_ptr1);
+       EXPECT_TRUE(ret == true);
+       ret = winMgr->registerSurface(zone.get(), surface_ptr2);
+       EXPECT_TRUE(ret == true);
+
+       std::list<std::shared_ptr<DSWindow>> winList = zone->getWindowList();
+       int id = 0;
+       for (auto w : winList)
+       {
+               resultWindow[id] = w.get();
+               id++;
+       }
+       EXPECT_TRUE(resultWindow[0]->surface() == surface_ptr2);
+       EXPECT_TRUE(resultWindow[1]->surface() == surface_ptr1);
+       EXPECT_TRUE(resultWindow[2]->surface() == surface_ptr0);
+
+       // ACTIVATE window
+       winMgr->activateWindow(surface_ptr0);
+
+       winList = zone->getWindowList();
+       id = 0;
+       for (auto w : winList)
+       {
+               resultWindow[id] = w.get();
+               id++;
+       }
+       EXPECT_TRUE(resultWindow[0]->surface() == surface_ptr0);
+       EXPECT_TRUE(resultWindow[1]->surface() == surface_ptr2);
+       EXPECT_TRUE(resultWindow[2]->surface() == surface_ptr1);
+
+       // LOWER window
+       winMgr->lowerWindow(surface_ptr2);
+
+       winList = zone->getWindowList();
+       id = 0;
+       for (auto w : winList)
+       {
+               resultWindow[id] = w.get();
+               id++;
+       }
+       EXPECT_TRUE(resultWindow[0]->surface() == surface_ptr0);
+       EXPECT_TRUE(resultWindow[1]->surface() == surface_ptr1);
+       EXPECT_TRUE(resultWindow[2]->surface() == surface_ptr2);
+
+       // RAISE window
+       winMgr->raiseWindow(surface_ptr2);
+
+       winList = zone->getWindowList();
+       id = 0;
+       for (auto w : winList)
+       {
+               resultWindow[id] = w.get();
+               id++;
+       }
+       EXPECT_TRUE(resultWindow[0]->surface() == surface_ptr2);
+       EXPECT_TRUE(resultWindow[1]->surface() == surface_ptr0);
+       EXPECT_TRUE(resultWindow[2]->surface() == surface_ptr1);
+
+       DSWindowManager::releaseInstance();
+}
+
+TEST_F(DSWindowManagerTest, FocusTest)
+{
+       bool ret = false;
+       DSWindow *window = nullptr;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       DSWaylandSurface *surface_ptr = surface.get();
+       EXPECT_TRUE(surface_ptr != nullptr);
+
+       zone->testCreateWindow(surface);
+
+       ret = winMgr->registerSurface(zone.get(), surface_ptr);
+       EXPECT_TRUE(ret == true);
+
+       std::list<std::shared_ptr<DSWindow>> winList = zone->getWindowList();
+       for (auto w : winList)
+       {
+               if (w->surface() == surface_ptr)
+               {
+                       window = w.get();
+               }
+       }
+       EXPECT_TRUE(window != nullptr);
+
+       EXPECT_TRUE(window->getSkipFocus() == false);
+
+       winMgr->setWindowSkipFocus(surface_ptr, true);
+       EXPECT_TRUE(window->getSkipFocus() == true);
 }
 
+TEST_F(DSWindowManagerTest, KeyboardTest)
+{
+       bool ret = false;
+
+       DSWindowManager *winMgr = DSWindowManager::getInstance();
+       EXPECT_TRUE(winMgr != nullptr);
+
+       auto zone = std::make_shared<DSZone>();
+       EXPECT_TRUE(zone != nullptr);
+
+       auto surface = std::make_shared<DSWaylandSurface>();
+       EXPECT_TRUE(surface != nullptr);
+
+       DSWaylandSurface *surface_ptr = surface.get();
+       EXPECT_TRUE(surface_ptr != nullptr);
+
+       zone->testCreateWindow(surface);
+
+       ret = winMgr->registerSurface(zone.get(), surface_ptr);
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->setWindowVkbdFloating(surface_ptr, true);
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->getWindowVkbdFloating(surface_ptr);
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->setWindowVkbdFloating(surface_ptr, false);
+       EXPECT_TRUE(ret == true);
+
+       ret = winMgr->getWindowVkbdFloating(surface_ptr);
+       EXPECT_TRUE(ret == false);
+}