From 3d3876b9cbb4d1d3c227b3149366f58cdd63b646 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Fri, 14 Aug 2020 17:23:18 +0900 Subject: [PATCH 01/16] DSSignalBroker: add skeleton codes Change-Id: I90427a9efac9298c9222a9fff6e58a667e390b4d Signed-off-by: Junseok, Kim --- src/DSSignal/DSSignalBroker.cpp | 110 ++++++++++++++++++++++++++++++++++++++++ src/DSSignal/DSSignalBroker.h | 58 +++++++++++++++++++++ src/meson.build | 2 + tests/DSSignalBroker-test.cpp | 85 +++++++++++++++++++++++++++++++ tests/meson.build | 1 + 5 files changed, 256 insertions(+) create mode 100644 src/DSSignal/DSSignalBroker.cpp create mode 100644 src/DSSignal/DSSignalBroker.h create mode 100644 tests/DSSignalBroker-test.cpp diff --git a/src/DSSignal/DSSignalBroker.cpp b/src/DSSignal/DSSignalBroker.cpp new file mode 100644 index 0000000..cdb1aad --- /dev/null +++ b/src/DSSignal/DSSignalBroker.cpp @@ -0,0 +1,110 @@ +/* +* Copyright © 2020 Samsung Electronics co., Ltd. All Rights Reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice (including the next +* paragraph) shall be included in all copies or substantial portions of the +* Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +* DEALINGS IN THE SOFTWARE. +*/ + +#include + +namespace display_server +{ + +std::mutex DSSignalBroker::__mutex; +DSSignalBroker* DSSignalBroker::__signalBroker { nullptr }; + +DSSignalBroker::DSSignalBroker(DSObject *parent) +{ +} + +DSSignalBroker::~DSSignalBroker() +{ +} + +DSSignalBroker *DSSignalBroker::getInstance() +{ + std::lock_guard tLock(__mutex); + + if (!__signalBroker) + { + __signalBroker = new DSSignalBroker(new DSObject); + DSLOG_INF("DSSignalBroker", "DSSignalBroker instance has been created !"); + } + + return __signalBroker; +} + +void DSSignalBroker::releaseInstance() +{ + std::lock_guard tLock(__mutex); + + if (__signalBroker && __signalBroker->__signalHash.empty()) + { + delete __signalBroker; + __signalBroker = nullptr; + DSLOG_INF("DSSignalBroker", "DSSignalBroker instance has been removed !"); + } +} + +bool DSSignalBroker::registerCallback(std::string signalStr, DSObject *slot, std::function func) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + { + DSLOG_INF("DSSignalBroker","registerCallback:: cannot find signal, add new one %s", signalStr.c_str()); + + __signalBroker->__signalHash[signalStr] = new DSSignal(); + } + + __signalBroker->__signalHash[signalStr]->connect(slot, func); + + return true; +} + +bool DSSignalBroker::deregisterCallback(std::string signalStr, DSObject *slot, std::function func) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + return false; + + // TODO: have to impl disconnect method in DSSignal + //__signalBroker->__signalHash[signalStr]->disconnect(slot, func); + + return true; +} + +bool DSSignalBroker::emitSignal(std::string signalStr, void *arg) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + { + DSLOG_INF("DSSignalBroker","emitSignal:: cannot find signal, add new one %s", signalStr.c_str()); + + __signalBroker->__signalHash[signalStr] = new DSSignal(); + } + + __signalBroker->__signalHash[signalStr]->emit(arg); + + return true; +} + +} // end of namespace display_server \ No newline at end of file diff --git a/src/DSSignal/DSSignalBroker.h b/src/DSSignal/DSSignalBroker.h new file mode 100644 index 0000000..2e503a0 --- /dev/null +++ b/src/DSSignal/DSSignalBroker.h @@ -0,0 +1,58 @@ +/* +* Copyright © 2020 Samsung Electronics co., Ltd. All Rights Reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice (including the next +* paragraph) shall be included in all copies or substantial portions of the +* Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +* DEALINGS IN THE SOFTWARE. +*/ + +#ifndef __DS_SIGNAL_BROKER_H__ +#define __DS_SIGNAL_BROKER_H__ + +#include +#include +#include + +namespace display_server +{ + +class DSSignalBroker : public DSObject +{ +public: + static DSSignalBroker *getInstance(); + static void releaseInstance(); + + // TODO: needs arguments using signal (now only supports void*) + bool registerCallback(std::string signalStr, DSObject *slot, std::function func); + bool deregisterCallback(std::string signalStr, DSObject *slot, std::function func); + bool emitSignal(std::string signalStr, void *arg); + +private: + static std::mutex __mutex; + static DSSignalBroker *__signalBroker; + + std::unordered_map *> __signalHash; + + DSSignalBroker() = delete; + ~DSSignalBroker(); + DSSignalBroker(DSObject *parent); +}; + +} // end of namespace display_server + +#endif // end of __DS_SIGNAL_BROKER_H__ diff --git a/src/meson.build b/src/meson.build index 9facc3c..9ebeb3e 100644 --- a/src/meson.build +++ b/src/meson.build @@ -52,6 +52,8 @@ libds_srcs = [ 'DSSeat/DSTouch.h', 'DSSignal/DSSignal.cpp', 'DSSignal/DSSignal.h', + 'DSSignal/DSSignalBroker.cpp', + 'DSSignal/DSSignalBroker.h', 'DSCore/DSStruct.h', 'DSCore/DSCore.h', 'DSWaylandExtension/DSWaylandExtension.cpp', diff --git a/tests/DSSignalBroker-test.cpp b/tests/DSSignalBroker-test.cpp new file mode 100644 index 0000000..1b3ace7 --- /dev/null +++ b/tests/DSSignalBroker-test.cpp @@ -0,0 +1,85 @@ +/* +* Copyright © 2020 Samsung Electronics co., Ltd. All Rights Reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice (including the next +* paragraph) shall be included in all copies or substantial portions of the +* Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +* DEALINGS IN THE SOFTWARE. +*/ + +#include +#include "libds-tests.h" +#include "DSSignal.h" +#include "DSSignalBroker.h" +#include "DSDebugLog.h" + +using namespace display_server; + +class DSSignalBrokerTest : public ::testing::Test +{ +public: + void SetUp(void) override + { + res_lambda = false; + } + void TearDown(void) override + {} + + bool res_lambda; +}; + +TEST_F(DSSignalBrokerTest, getInstance) +{ + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + EXPECT_TRUE(sigbro != nullptr); + + if (sigbro) + sigbro->releaseInstance(); +} + +TEST_F(DSSignalBrokerTest, registerCallback) +{ + bool res = false; + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + std::string testSignal = "TestSignalBroker"; + EXPECT_TRUE(sigbro != nullptr); + + res = sigbro->registerCallback(testSignal, new DSObject, [&](void * arg) { + DSLOG_INF("DSTEST", "%s is invoked!, input: %p", __func__, arg); + res_lambda = true; + }); + EXPECT_TRUE(res); + + if (sigbro) + sigbro->releaseInstance(); +} + +TEST_F(DSSignalBrokerTest, emitSignal) +{ + bool res = false; + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + std::string testSignal = "TestSignalBroker"; + EXPECT_TRUE(sigbro != nullptr); + + // NOTICE: If registerCallback test didn't called, this test will fail. + res = sigbro->emitSignal(testSignal, nullptr); + EXPECT_TRUE(res); + EXPECT_TRUE(res_lambda); + + if (sigbro) + sigbro->releaseInstance(); +} diff --git a/tests/meson.build b/tests/meson.build index 1ef31cc..372bf7e 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -17,6 +17,7 @@ libds_tests_srcs = [ 'DSDebugLog-test.cpp', 'DSDisplayDeviceTDMImpl-test.cpp', 'DSSignal-test.cpp', + 'DSSignalBroker-test.cpp', 'DSWindowManager-test.cpp', 'DSWindow-test.cpp', 'DSWindowShell-test.cpp', -- 2.7.4 From 2631796eb2e895a8a5aa3a9dbbe4b27abe8601e4 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Wed, 19 Aug 2020 17:56:25 +0900 Subject: [PATCH 02/16] DSSignalBroker: use template for respond to various args Change-Id: I9a386e712804ae23b5467947b4f27f92ad23ab39 Signed-off-by: Junseok, Kim --- src/DSSignal/DSSignalBroker.cpp | 57 ++++---------------- src/DSSignal/DSSignalBroker.h | 63 ++++++++++++++++++++-- tests/DSSignalBroker-test.cpp | 117 +++++++++++++++++++++++++++++++--------- 3 files changed, 162 insertions(+), 75 deletions(-) diff --git a/src/DSSignal/DSSignalBroker.cpp b/src/DSSignal/DSSignalBroker.cpp index cdb1aad..f8e4cfa 100644 --- a/src/DSSignal/DSSignalBroker.cpp +++ b/src/DSSignal/DSSignalBroker.cpp @@ -35,6 +35,16 @@ DSSignalBroker::DSSignalBroker(DSObject *parent) DSSignalBroker::~DSSignalBroker() { + if (__signalBroker) + { + if (!__signalBroker->__signalHash.empty()) + { + for (auto hashpairs : __signalBroker->__signalHash) + { + delete hashpairs.second; + } + } + } } DSSignalBroker *DSSignalBroker::getInstance() @@ -58,53 +68,8 @@ void DSSignalBroker::releaseInstance() { delete __signalBroker; __signalBroker = nullptr; - DSLOG_INF("DSSignalBroker", "DSSignalBroker instance has been removed !"); + DSLOG_INF("DSSignalBroker", "DSSignalBroker instance has been removed !"); } } -bool DSSignalBroker::registerCallback(std::string signalStr, DSObject *slot, std::function func) -{ - if (!__signalBroker) return false; - - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) - { - DSLOG_INF("DSSignalBroker","registerCallback:: cannot find signal, add new one %s", signalStr.c_str()); - - __signalBroker->__signalHash[signalStr] = new DSSignal(); - } - - __signalBroker->__signalHash[signalStr]->connect(slot, func); - - return true; -} - -bool DSSignalBroker::deregisterCallback(std::string signalStr, DSObject *slot, std::function func) -{ - if (!__signalBroker) return false; - - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) - return false; - - // TODO: have to impl disconnect method in DSSignal - //__signalBroker->__signalHash[signalStr]->disconnect(slot, func); - - return true; -} - -bool DSSignalBroker::emitSignal(std::string signalStr, void *arg) -{ - if (!__signalBroker) return false; - - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) - { - DSLOG_INF("DSSignalBroker","emitSignal:: cannot find signal, add new one %s", signalStr.c_str()); - - __signalBroker->__signalHash[signalStr] = new DSSignal(); - } - - __signalBroker->__signalHash[signalStr]->emit(arg); - - return true; -} - } // end of namespace display_server \ No newline at end of file diff --git a/src/DSSignal/DSSignalBroker.h b/src/DSSignal/DSSignalBroker.h index 2e503a0..27a55dd 100644 --- a/src/DSSignal/DSSignalBroker.h +++ b/src/DSSignal/DSSignalBroker.h @@ -38,9 +38,12 @@ public: static void releaseInstance(); // TODO: needs arguments using signal (now only supports void*) - bool registerCallback(std::string signalStr, DSObject *slot, std::function func); - bool deregisterCallback(std::string signalStr, DSObject *slot, std::function func); - bool emitSignal(std::string signalStr, void *arg); + template + bool registerCallback(std::string signalStr, DSObject *slot, std::function func); + template + bool deregisterCallback(std::string signalStr, DSObject *slot, std::function func); + template + bool emitSignal(std::string signalStr, Args...); private: static std::mutex __mutex; @@ -53,6 +56,60 @@ private: DSSignalBroker(DSObject *parent); }; +template +bool DSSignalBroker::registerCallback(std::string signalStr, DSObject *slot, std::function func) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + { + DSLOG_INF("DSSignalBroker","registerCallback:: cannot find signal, add new one %s", signalStr.c_str()); + + __signalBroker->__signalHash[signalStr] = reinterpret_cast *> (new DSSignal()); + } + + DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); + if (signal) + signal->connect(slot, func); + + return true; +} + +template +bool DSSignalBroker::deregisterCallback(std::string signalStr, DSObject *slot, std::function func) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + return false; + + // TODO: have to impl disconnect method in DSSignal + //DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); + //if (signal) + //signal->disconnect(slot, func); + + return true; +} + +template +bool DSSignalBroker::emitSignal(std::string signalStr, Args... args) +{ + if (!__signalBroker) return false; + + if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + { + DSLOG_INF("DSSignalBroker","emitSignal:: cannot find signal, add new one %s", signalStr.c_str()); + + __signalBroker->__signalHash[signalStr] = reinterpret_cast *> (new DSSignal()); + } + + DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); + if (signal) + signal->emit(args...); + + return true; +} + } // end of namespace display_server #endif // end of __DS_SIGNAL_BROKER_H__ diff --git a/tests/DSSignalBroker-test.cpp b/tests/DSSignalBroker-test.cpp index 1b3ace7..a4532b9 100644 --- a/tests/DSSignalBroker-test.cpp +++ b/tests/DSSignalBroker-test.cpp @@ -33,13 +33,74 @@ class DSSignalBrokerTest : public ::testing::Test { public: void SetUp(void) override - { - res_lambda = false; - } + {} void TearDown(void) override {} +}; + +class MockSignalBrokerSender : public DSObject +{ +public: + MockSignalBrokerSender() {} + ~MockSignalBrokerSender() {} + + bool sendSignal(std::string signalString) + { + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + bool res = false; + + if (sigbro == nullptr) + return false; + + res = sigbro->emitSignal(signalString, true); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } +}; + +class MockSignalBrokerReceiver : public DSObject +{ +public: + MockSignalBrokerReceiver() = delete; + MockSignalBrokerReceiver(std::string targetSignal) + { + __targetSignal = targetSignal; + } + ~MockSignalBrokerReceiver() {} + +public: + std::string __targetSignal; + bool __result; + +public: + bool registerCallback() + { + bool res = false; + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + if (sigbro == nullptr) return false; + + std::function func = std::bind(&MockSignalBrokerReceiver::callbackTestSignalBroker, this, std::placeholders::_1); + res = sigbro->registerCallback(__targetSignal, this, func); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } - bool res_lambda; + void callbackTestSignalBroker(bool arg) + { + DSLOG_INF("DSTEST", "%s is invoked!, arg: %d", __func__, arg); + __result = arg; + } + + bool getResult() + { + return __result; + } }; TEST_F(DSSignalBrokerTest, getInstance) @@ -53,33 +114,37 @@ TEST_F(DSSignalBrokerTest, getInstance) TEST_F(DSSignalBrokerTest, registerCallback) { - bool res = false; - DSSignalBroker *sigbro = DSSignalBroker::getInstance(); - std::string testSignal = "TestSignalBroker"; - EXPECT_TRUE(sigbro != nullptr); + auto receiver = std::make_shared("TestSignalBroker"); + receiver->registerCallback(); +} - res = sigbro->registerCallback(testSignal, new DSObject, [&](void * arg) { - DSLOG_INF("DSTEST", "%s is invoked!, input: %p", __func__, arg); - res_lambda = true; - }); - EXPECT_TRUE(res); +TEST_F(DSSignalBrokerTest, emitSignal) +{ + auto receiver = std::make_shared("TestSignalBroker"); + auto sender = std::make_shared(); + ASSERT_TRUE(receiver != nullptr); + ASSERT_TRUE(sender != nullptr); - if (sigbro) - sigbro->releaseInstance(); + receiver->registerCallback(); + EXPECT_TRUE(sender->sendSignal("TestSignalBroker")); + EXPECT_TRUE(receiver->getResult()); } -TEST_F(DSSignalBrokerTest, emitSignal) +TEST_F(DSSignalBrokerTest, emitSignal2) { - bool res = false; - DSSignalBroker *sigbro = DSSignalBroker::getInstance(); - std::string testSignal = "TestSignalBroker"; - EXPECT_TRUE(sigbro != nullptr); + auto receiver1 = std::make_shared("TestSignalBroker"); + auto receiver2 = std::make_shared("TestSignalBroker2"); + auto sender = std::make_shared(); + ASSERT_TRUE(receiver1 != nullptr); + ASSERT_TRUE(receiver2 != nullptr); + ASSERT_TRUE(sender != nullptr); - // NOTICE: If registerCallback test didn't called, this test will fail. - res = sigbro->emitSignal(testSignal, nullptr); - EXPECT_TRUE(res); - EXPECT_TRUE(res_lambda); + receiver1->registerCallback(); + receiver2->registerCallback(); + EXPECT_TRUE(sender->sendSignal("TestSignalBroker")); + EXPECT_TRUE(receiver1->getResult()); + EXPECT_TRUE(receiver2->getResult() != true); - if (sigbro) - sigbro->releaseInstance(); + EXPECT_TRUE(sender->sendSignal("TestSignalBroker2")); + EXPECT_TRUE(receiver2->getResult()); } -- 2.7.4 From dfa70234dfe173becde2db56d89df922ab7b5458 Mon Sep 17 00:00:00 2001 From: "Junseok, Kim" Date: Fri, 28 Aug 2020 20:06:06 +0900 Subject: [PATCH 03/16] DSSignalBroker: added registerSignal and add DSObject argument for signal methods Change-Id: I2b97b60b195740b134a2cdd1d7fbcaa082679c9b Signed-off-by: Junseok, Kim --- src/DSSignal/DSSignalBroker.cpp | 2 +- src/DSSignal/DSSignalBroker.h | 140 ++++++++++++++++++----- tests/DSSignalBroker-test.cpp | 239 +++++++++++++++++++++++++++++++--------- 3 files changed, 301 insertions(+), 80 deletions(-) diff --git a/src/DSSignal/DSSignalBroker.cpp b/src/DSSignal/DSSignalBroker.cpp index f8e4cfa..58c53c2 100644 --- a/src/DSSignal/DSSignalBroker.cpp +++ b/src/DSSignal/DSSignalBroker.cpp @@ -41,7 +41,7 @@ DSSignalBroker::~DSSignalBroker() { for (auto hashpairs : __signalBroker->__signalHash) { - delete hashpairs.second; + delete hashpairs.second.signal; } } } diff --git a/src/DSSignal/DSSignalBroker.h b/src/DSSignal/DSSignalBroker.h index 27a55dd..5674ade 100644 --- a/src/DSSignal/DSSignalBroker.h +++ b/src/DSSignal/DSSignalBroker.h @@ -37,19 +37,38 @@ public: static DSSignalBroker *getInstance(); static void releaseInstance(); - // TODO: needs arguments using signal (now only supports void*) + template + bool registerSignal(std::string signalStr, DSObject *obj); + template + bool emitSignal(std::string signalStr, DSObject *obj, Args...); template bool registerCallback(std::string signalStr, DSObject *slot, std::function func); template bool deregisterCallback(std::string signalStr, DSObject *slot, std::function func); - template - bool emitSignal(std::string signalStr, Args...); private: static std::mutex __mutex; static DSSignalBroker *__signalBroker; - std::unordered_map *> __signalHash; + struct stRegisteredSignal + { + std::string signalName; + std::string className; + DSObject *obj; + DSSignal *signal; + + public: + stRegisteredSignal(std::string sn, DSObject *inpObj, DSSignal *inpSignal) + { + signalName = sn; + className = inpObj->getName(); + obj = inpObj; + signal = inpSignal; + } + + }; + + std::unordered_multimap __signalHash; DSSignalBroker() = delete; ~DSSignalBroker(); @@ -57,56 +76,121 @@ private: }; template -bool DSSignalBroker::registerCallback(std::string signalStr, DSObject *slot, std::function func) +bool DSSignalBroker::registerSignal(std::string signalStr, DSObject *obj) { if (!__signalBroker) return false; - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + if (__signalBroker->__signalHash.find(signalStr) != __signalBroker->__signalHash.end()) { - DSLOG_INF("DSSignalBroker","registerCallback:: cannot find signal, add new one %s", signalStr.c_str()); - - __signalBroker->__signalHash[signalStr] = reinterpret_cast *> (new DSSignal()); + auto range = __signalBroker->__signalHash.equal_range(signalStr); + for (auto iter = range.first; + iter != range.second; + iter++) + { + if (iter->second.obj == obj) + { + DSLOG_INF("DSSignalBroker","emitSignal:: already registered signal: %s", signalStr.c_str()); + return false; + } + else + { + DSLOG_DBG("DSSignalBroker", "searching same item: %s, obj(%p):%s", iter->second.signalName.c_str(), iter->second.obj, iter->second.className.c_str()); + } + + } } + DSSignal *signal = reinterpret_cast *> (new DSSignal()); + __signalBroker->__signalHash.insert(std::make_pair(signalStr, stRegisteredSignal(signalStr, obj, signal))); - DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); - if (signal) - signal->connect(slot, func); + DSLOG_DBG("DSSignalBroker","registerSignal:: registered new signal (name:%s, class(%p):%s, signal:%p)", + signalStr.c_str(), obj, obj->getName().c_str(), signal); return true; } template -bool DSSignalBroker::deregisterCallback(std::string signalStr, DSObject *slot, std::function func) +bool DSSignalBroker::emitSignal(std::string signalStr, DSObject *obj, Args... args) { if (!__signalBroker) return false; - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + if (__signalBroker->__signalHash.find(signalStr) != __signalBroker->__signalHash.end()) + { + auto range = __signalBroker->__signalHash.equal_range(signalStr); + for (auto iter = range.first; + iter != range.second; + iter++) + { + if (iter->second.obj == obj)// || iter->second.className == obj->getName()) + { + DSSignal *signal = reinterpret_cast *>(iter->second.signal); + if (signal) + { + signal->emit(args...); + DSLOG_DBG("DSSignalBroker","emitSignal:: signal emit (name:%s, class(%p):%s, signal:%p)", + iter->second.signalName.c_str(), iter->second.obj, iter->second.obj->getName().c_str(), iter->second.signal); + } + else + return false; + + return true; + } + } + } + else + { + DSLOG_INF("DSSignalBroker","emitSignal:: cannot find registered signal: %s", signalStr.c_str()); return false; + } - // TODO: have to impl disconnect method in DSSignal - //DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); - //if (signal) - //signal->disconnect(slot, func); - - return true; + return false; } template -bool DSSignalBroker::emitSignal(std::string signalStr, Args... args) +bool DSSignalBroker::registerCallback(std::string signalStr, DSObject *slot, std::function func) { if (!__signalBroker) return false; - if (__signalBroker->__signalHash.find(signalStr) == __signalBroker->__signalHash.end()) + if (__signalBroker->__signalHash.find(signalStr) != __signalBroker->__signalHash.end()) + { + auto range = __signalBroker->__signalHash.equal_range(signalStr); + for (auto iter = range.first; + iter != range.second; + iter++) { - DSLOG_INF("DSSignalBroker","emitSignal:: cannot find signal, add new one %s", signalStr.c_str()); - - __signalBroker->__signalHash[signalStr] = reinterpret_cast *> (new DSSignal()); + DSSignal *signal = reinterpret_cast *>(iter->second.signal); + if (signal) + signal->connect(slot, func); } + } + else + { + DSLOG_INF("DSSignalBroker","registerCallback:: cannot find signal: %s", signalStr.c_str()); + return false; + } + + return true; +} - DSSignal *signal = reinterpret_cast *>(__signalBroker->__signalHash[signalStr]); - if (signal) - signal->emit(args...); +template +bool DSSignalBroker::deregisterCallback(std::string signalStr, DSObject *slot, std::function func) +{ + // TODO: have to impl disconnect method in DSSignal + /* + if (!__signalBroker) return false; + if (__signalBroker->__signalHash.find(signalStr) != __signalBroker->__signalHash.end()) + { + auto range = __signalBroker->__signalHash.equal_range(signalStr); + for (auto iter = range.first; + iter != range.second; + iter++) + { + DSSignal *signal = reinterpret_cast *>(iter->second.signal); + if (signal) + signal->disconnect(slot, func); + } + } + */ return true; } diff --git a/tests/DSSignalBroker-test.cpp b/tests/DSSignalBroker-test.cpp index a4532b9..4484885 100644 --- a/tests/DSSignalBroker-test.cpp +++ b/tests/DSSignalBroker-test.cpp @@ -29,22 +29,19 @@ using namespace display_server; -class DSSignalBrokerTest : public ::testing::Test +struct stItem { -public: - void SetUp(void) override - {} - void TearDown(void) override - {} + std::string str1; + std::string str2; }; -class MockSignalBrokerSender : public DSObject +class MockSender : public DSObject { public: - MockSignalBrokerSender() {} - ~MockSignalBrokerSender() {} + MockSender() {} + ~MockSender() {} - bool sendSignal(std::string signalString) + bool registerSignal(std::string signalString) { DSSignalBroker *sigbro = DSSignalBroker::getInstance(); bool res = false; @@ -52,7 +49,57 @@ public: if (sigbro == nullptr) return false; - res = sigbro->emitSignal(signalString, true); + res = sigbro->registerSignal(signalString, this); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } + + bool sendSignal1(std::string signalString, int data) + { + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + bool res = false; + + if (sigbro == nullptr) + return false; + + res = sigbro->emitSignal(signalString, this, data); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } + + bool sendSignal2(std::string signalString, double data) + { + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + bool res = false; + + if (sigbro == nullptr) + return false; + + res = sigbro->emitSignal(signalString, this, data); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } + + bool sendSignal3(std::string signalString, std::string data1, std::string data2, std::string data3) + { + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + bool res = false; + + if (sigbro == nullptr) + return false; + + struct stItem testItem = {data2, data3}; + + res = sigbro->emitSignal(signalString, this, data1, testItem); if (sigbro) sigbro->releaseInstance(); @@ -61,29 +108,46 @@ public: } }; -class MockSignalBrokerReceiver : public DSObject +class MockReceiver : public DSObject { public: - MockSignalBrokerReceiver() = delete; - MockSignalBrokerReceiver(std::string targetSignal) + MockReceiver() : + result1(0), + result2(0.0), + result3("") { - __targetSignal = targetSignal; } - ~MockSignalBrokerReceiver() {} + ~MockReceiver() {} public: - std::string __targetSignal; - bool __result; + int result1; + double result2; + std::string result3; public: - bool registerCallback() + bool registerCallback1(std::string targetSignal) + { + bool res = false; + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + if (sigbro == nullptr) return false; + + std::function func = std::bind(&MockReceiver::UserCallback1, this, std::placeholders::_1); + res = sigbro->registerCallback(targetSignal, this, func); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } + + bool registerCallback2(std::string targetSignal) { bool res = false; DSSignalBroker *sigbro = DSSignalBroker::getInstance(); if (sigbro == nullptr) return false; - std::function func = std::bind(&MockSignalBrokerReceiver::callbackTestSignalBroker, this, std::placeholders::_1); - res = sigbro->registerCallback(__targetSignal, this, func); + std::function func = std::bind(&MockReceiver::UserCallback2, this, std::placeholders::_1); + res = sigbro->registerCallback(targetSignal, this, func); if (sigbro) sigbro->releaseInstance(); @@ -91,18 +155,52 @@ public: return res; } - void callbackTestSignalBroker(bool arg) + bool registerCallback3(std::string targetSignal) + { + bool res = false; + DSSignalBroker *sigbro = DSSignalBroker::getInstance(); + if (sigbro == nullptr) return false; + + std::function func = std::bind(&MockReceiver::UserCallback3, this, std::placeholders::_1, std::placeholders::_2); + res = sigbro->registerCallback(targetSignal, this, func); + + if (sigbro) + sigbro->releaseInstance(); + + return res; + } + + void UserCallback1(int arg) { DSLOG_INF("DSTEST", "%s is invoked!, arg: %d", __func__, arg); - __result = arg; + result1 = arg; } - bool getResult() + void UserCallback2(double arg) { - return __result; + DSLOG_INF("DSTEST", "%s is invoked!, arg: %d", __func__, arg); + result2 = arg; + } + + void UserCallback3(std::string arg1, struct stItem arg2) + { + DSLOG_INF("DSTEST", "%s is invoked!, arg1: %s, arg2{%s, %s}", __func__, arg1.c_str(), arg2.str1.c_str(), arg2.str2.c_str()); + result3 = arg1; } }; +class DSSignalBrokerTest : public ::testing::Test +{ +public: + void SetUp(void) override + {} + void TearDown(void) override + {} +}; + +std::shared_ptr __receiver; +std::shared_ptr __sender; + TEST_F(DSSignalBrokerTest, getInstance) { DSSignalBroker *sigbro = DSSignalBroker::getInstance(); @@ -112,39 +210,78 @@ TEST_F(DSSignalBrokerTest, getInstance) sigbro->releaseInstance(); } +TEST_F(DSSignalBrokerTest, registerSignal) +{ + __sender = std::make_shared(); + ASSERT_TRUE(__sender != nullptr); + + __sender->registerSignal("SampleSignal1"); +} + TEST_F(DSSignalBrokerTest, registerCallback) { - auto receiver = std::make_shared("TestSignalBroker"); - receiver->registerCallback(); + __receiver = std::make_shared(); + ASSERT_TRUE(__receiver != nullptr); + + __receiver->registerCallback1("SampleSignal1"); } TEST_F(DSSignalBrokerTest, emitSignal) { - auto receiver = std::make_shared("TestSignalBroker"); - auto sender = std::make_shared(); - ASSERT_TRUE(receiver != nullptr); - ASSERT_TRUE(sender != nullptr); - - receiver->registerCallback(); - EXPECT_TRUE(sender->sendSignal("TestSignalBroker")); - EXPECT_TRUE(receiver->getResult()); + ASSERT_TRUE(__sender != nullptr); + ASSERT_TRUE(__receiver != nullptr); + + EXPECT_TRUE(__sender->sendSignal1("SampleSignal1", 1)); + EXPECT_TRUE(__receiver->result1 == 1); } -TEST_F(DSSignalBrokerTest, emitSignal2) +TEST_F(DSSignalBrokerTest, registerAndEmit1) { - auto receiver1 = std::make_shared("TestSignalBroker"); - auto receiver2 = std::make_shared("TestSignalBroker2"); - auto sender = std::make_shared(); - ASSERT_TRUE(receiver1 != nullptr); - ASSERT_TRUE(receiver2 != nullptr); - ASSERT_TRUE(sender != nullptr); - - receiver1->registerCallback(); - receiver2->registerCallback(); - EXPECT_TRUE(sender->sendSignal("TestSignalBroker")); - EXPECT_TRUE(receiver1->getResult()); - EXPECT_TRUE(receiver2->getResult() != true); - - EXPECT_TRUE(sender->sendSignal("TestSignalBroker2")); - EXPECT_TRUE(receiver2->getResult()); + auto sender1 = std::make_shared(); + auto sender2 = std::make_shared(); + + auto receiver1 = std::make_shared(); + auto receiver2 = std::make_shared(); + + ASSERT_TRUE(sender1 != nullptr && + sender2 != nullptr && + receiver1 != nullptr && + receiver2 != nullptr); + + // 1. register Signal + EXPECT_TRUE(sender1->registerSignal("SampleSignal1")); + EXPECT_TRUE(sender2->registerSignal("SampleSignal2")); + + // 2. register Callback + EXPECT_TRUE(receiver1->registerCallback1("SampleSignal1")); + EXPECT_TRUE(receiver2->registerCallback2("SampleSignal2")); + + // 3. emit Signal + EXPECT_TRUE(sender1->sendSignal1("SampleSignal1", 11)); + EXPECT_TRUE(sender2->sendSignal2("SampleSignal2", 10.10)); + + // 4. see Changes + EXPECT_TRUE(receiver1->result1 == 11); + EXPECT_TRUE(receiver2->result2 == 10.10); } + +TEST_F(DSSignalBrokerTest, emitMultiItems) +{ + auto sender = std::make_shared(); + auto receiver = std::make_shared(); + + ASSERT_TRUE(sender != nullptr && + receiver != nullptr); + + // 1. register Signal + EXPECT_TRUE(sender->registerSignal("SampleSignal3")); + + // 2. register Callback + EXPECT_TRUE(receiver->registerCallback3("SampleSignal3")); + + // 3. emit Signal + EXPECT_TRUE(sender->sendSignal3("SampleSignal3", "Test", "Hello", "signal")); + + // 4. see Changes + EXPECT_TRUE(receiver->result3 == "Test"); +} \ No newline at end of file -- 2.7.4 From cfc166a98f2c5a8e9dc72080b1fc5f693969dc94 Mon Sep 17 00:00:00 2001 From: Sung-Jin Park Date: Tue, 1 Sep 2020 21:17:36 +0900 Subject: [PATCH 04/16] tests: set default XDG_RUNTIME_DIR to /tmp Change-Id: Id447afec35ddbf83f4d09ec57a040ac9e6a2fcbe Signed-off-by: Sung-Jin Park --- tests/DSBufferManager-test.cpp | 17 ++++++++------- tests/DSBufferRef-test.cpp | 18 ++++++++-------- tests/DSBufferTBMImpl-test.cpp | 17 ++++++++------- tests/DSCanvas-test.cpp | 13 ++++++++---- tests/DSClient-test.cpp | 17 ++++++++------- tests/DSCompositor-test.cpp | 17 ++++++++------- tests/DSDebugLog-test.cpp | 13 ++++++++---- tests/DSDisplayArea-test.cpp | 17 ++++++++------- tests/DSDisplayDeviceTDMImpl-test.cpp | 18 ++++++++-------- tests/DSEventLoop-test.cpp | 13 ++++++++---- tests/DSInput-test.cpp | 13 ++++++++---- tests/DSKeyboard-test.cpp | 17 ++++++++------- tests/DSObject-test.cpp | 13 ++++++++---- tests/DSOutputImpl-test.cpp | 13 ++++++++---- tests/DSPointer-test.cpp | 17 ++++++++------- tests/DSPolicyArea-test.cpp | 13 ++++++++---- tests/DSProperty-test.cpp | 13 ++++++++---- tests/DSRefBase-test.cpp | 13 ++++++++---- tests/DSRenderEngineDaliImpl-test.cpp | 3 ++- tests/DSRenderEngineEcoreEvasImpl-test.cpp | 13 ++++++++---- tests/DSSeat-test.cpp | 17 ++++++++------- tests/DSSignal-test.cpp | 13 ++++++++---- tests/DSSignalBroker-test.cpp | 15 ++++++++----- tests/DSTextInput-test.cpp | 17 ++++++++------- tests/DSTizenAppinfo-test.cpp | 17 ++++++++------- tests/DSTouch-test.cpp | 17 ++++++++------- tests/DSTraceInfo-test.cpp | 17 ++++++++------- tests/DSWaylandBuffer-test.cpp | 13 ++++++++---- tests/DSWaylandCallback-test.cpp | 9 ++++++-- tests/DSWaylandClient-test.cpp | 17 ++++++++------- tests/DSWaylandCompositor-test.cpp | 17 ++++++++------- tests/DSWaylandExtension-test.cpp | 13 ++++++++---- tests/DSWaylandInputMethod-test.cpp | 3 ++- tests/DSWaylandInputMethodContext-test.cpp | 17 ++++++++------- tests/DSWaylandInputPanel-test.cpp | 17 ++++++++------- tests/DSWaylandInputPanelSurface-test.cpp | 17 ++++++++------- tests/DSWaylandKeyboard-test.cpp | 3 ++- tests/DSWaylandOutput-test.cpp | 13 ++++++++---- tests/DSWaylandPointer-test.cpp | 17 ++++++++------- tests/DSWaylandProtocolTrace-test.cpp | 28 ++++++++++++------------- tests/DSWaylandSeat-test.cpp | 17 ++++++++------- tests/DSWaylandSurface-test.cpp | 17 ++++++++------- tests/DSWaylandTextInput-test.cpp | 17 ++++++++------- tests/DSWaylandTextInputManager-test.cpp | 17 ++++++++------- tests/DSWaylandTizenAppinfo-test.cpp | 13 ++++++++---- tests/DSWaylandTizenIndicator-test.cpp | 13 ++++++++---- tests/DSWaylandTizenInputDevice-test.cpp | 13 ++++++++---- tests/DSWaylandTizenInputDeviceManager-test.cpp | 13 ++++++++---- tests/DSWaylandTizenLaunchEffect-test.cpp | 15 ++++++++----- tests/DSWaylandTizenPolicy-test.cpp | 13 ++++++++---- tests/DSWaylandTizenPolicyExt-test.cpp | 9 ++++++-- tests/DSWaylandTizenSurface-test.cpp | 13 ++++++++---- tests/DSWaylandTizenSurfaceShm-test.cpp | 13 ++++++++---- tests/DSWaylandTouch-test.cpp | 17 ++++++++------- tests/DSWaylandZxdgShellV6-test.cpp | 9 ++++++-- tests/DSWindow-test.cpp | 13 ++++++++---- tests/DSWindowManager-test.cpp | 15 +++++++------ tests/DSWindowShell-test.cpp | 13 ++++++++---- tests/DSXkb-test.cpp | 13 ++++++++---- tests/DSZone-test.cpp | 13 ++++++++---- tests/libds-tests.cpp | 1 + 61 files changed, 521 insertions(+), 341 deletions(-) diff --git a/tests/DSBufferManager-test.cpp b/tests/DSBufferManager-test.cpp index e21c556..9f6a1d2 100644 --- a/tests/DSBufferManager-test.cpp +++ b/tests/DSBufferManager-test.cpp @@ -32,14 +32,15 @@ using namespace display_server; class DSBufferManagerTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSBufferManagerTest, GetBufferManager) diff --git a/tests/DSBufferRef-test.cpp b/tests/DSBufferRef-test.cpp index 55a7c85..fa99f39 100644 --- a/tests/DSBufferRef-test.cpp +++ b/tests/DSBufferRef-test.cpp @@ -31,15 +31,15 @@ using namespace display_server; class DSBufferRefTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - - void TearDown(void) override - { - 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(DSBufferRefTest, CreateBufferRef) diff --git a/tests/DSBufferTBMImpl-test.cpp b/tests/DSBufferTBMImpl-test.cpp index 6f801e6..fac2480 100644 --- a/tests/DSBufferTBMImpl-test.cpp +++ b/tests/DSBufferTBMImpl-test.cpp @@ -31,14 +31,15 @@ using namespace display_server; class DSBufferTBMImplTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSBufferTBMImplTest, CreateBuffer) diff --git a/tests/DSCanvas-test.cpp b/tests/DSCanvas-test.cpp index 022e74d..a81a83e 100644 --- a/tests/DSCanvas-test.cpp +++ b/tests/DSCanvas-test.cpp @@ -33,10 +33,15 @@ using namespace display_server; class DSCanvasTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSCanvasTest, NewDSCanvas) diff --git a/tests/DSClient-test.cpp b/tests/DSClient-test.cpp index 4c16109..0896cc8 100644 --- a/tests/DSClient-test.cpp +++ b/tests/DSClient-test.cpp @@ -35,14 +35,15 @@ using namespace display_server; class DSClientTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSClientTest, NewDSClientWithDSWaylandClient) diff --git a/tests/DSCompositor-test.cpp b/tests/DSCompositor-test.cpp index 135920c..8de9fae 100644 --- a/tests/DSCompositor-test.cpp +++ b/tests/DSCompositor-test.cpp @@ -30,15 +30,16 @@ using namespace display_server; class DSCompositorTest : public ::testing::Test { public: - void SetUp(void) override - { + void SetUp(void) override + { // for wl_display_add_socket(private_loop->wl_display, "tdm-socket") at tdm_server_init - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - unsetenv("XDG_RUNTIME_DIR"); - } + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); + } + void TearDown(void) override + { + unsetenv("XDG_RUNTIME_DIR"); + } }; class MockCompositor : public DSCompositor diff --git a/tests/DSDebugLog-test.cpp b/tests/DSDebugLog-test.cpp index 78322b4..179a620 100644 --- a/tests/DSDebugLog-test.cpp +++ b/tests/DSDebugLog-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSDebugLogTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSDebugLogTest, GetInstance) diff --git a/tests/DSDisplayArea-test.cpp b/tests/DSDisplayArea-test.cpp index ac22be6..3fb3af7 100644 --- a/tests/DSDisplayArea-test.cpp +++ b/tests/DSDisplayArea-test.cpp @@ -33,15 +33,16 @@ using namespace display_server; class DSDisplayAreaTest : public ::testing::Test { public: - void SetUp(void) override - { + void SetUp(void) override + { // for wl_display_add_socket(private_loop->wl_display, "tdm-socket") at tdm_server_init - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - unsetenv("XDG_RUNTIME_DIR"); - } + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); + } + void TearDown(void) override + { + unsetenv("XDG_RUNTIME_DIR"); + } }; TEST_F(DSDisplayAreaTest, NewDSDisplayArea) diff --git a/tests/DSDisplayDeviceTDMImpl-test.cpp b/tests/DSDisplayDeviceTDMImpl-test.cpp index b23e6bd..dfc8e94 100644 --- a/tests/DSDisplayDeviceTDMImpl-test.cpp +++ b/tests/DSDisplayDeviceTDMImpl-test.cpp @@ -31,15 +31,15 @@ using namespace display_server; class DSDisplayDeviceTDMImplTest : public ::testing::Test { public: - void SetUp(void) override - { - // for wl_display_add_socket(private_loop->wl_display, "tdm-socket") at tdm_server_init - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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"); + } }; // DSDisplayDeviceTDMImpl diff --git a/tests/DSEventLoop-test.cpp b/tests/DSEventLoop-test.cpp index 5621af0..40915e5 100644 --- a/tests/DSEventLoop-test.cpp +++ b/tests/DSEventLoop-test.cpp @@ -30,10 +30,15 @@ using namespace display_server; class DSEventLoopTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSEventLoopTest, NewDSEventLoop) diff --git a/tests/DSInput-test.cpp b/tests/DSInput-test.cpp index 0109988..3090b30 100644 --- a/tests/DSInput-test.cpp +++ b/tests/DSInput-test.cpp @@ -31,10 +31,15 @@ using namespace display_server; class DSInputTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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"); + } }; class MockInput : public DSObject diff --git a/tests/DSKeyboard-test.cpp b/tests/DSKeyboard-test.cpp index 3c724b0..94aa630 100644 --- a/tests/DSKeyboard-test.cpp +++ b/tests/DSKeyboard-test.cpp @@ -34,14 +34,15 @@ using namespace display_server; class DSKeyboardTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSKeyboardTest, NewDSKeyboardWithDSSeat) diff --git a/tests/DSObject-test.cpp b/tests/DSObject-test.cpp index 065a96f..48e3465 100644 --- a/tests/DSObject-test.cpp +++ b/tests/DSObject-test.cpp @@ -30,10 +30,15 @@ using namespace display_server; class DSObjectTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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"); + } }; /* Temporary classes for implemting PImpl Idiom based on DSObject/DSObjectPrivate classes */ diff --git a/tests/DSOutputImpl-test.cpp b/tests/DSOutputImpl-test.cpp index 044264b..9f2d9df 100644 --- a/tests/DSOutputImpl-test.cpp +++ b/tests/DSOutputImpl-test.cpp @@ -32,10 +32,15 @@ using namespace display_server; class DSOutputTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSOutputTest, NewDSOutput) diff --git a/tests/DSPointer-test.cpp b/tests/DSPointer-test.cpp index f0cf678..d482d8a 100644 --- a/tests/DSPointer-test.cpp +++ b/tests/DSPointer-test.cpp @@ -34,14 +34,15 @@ using namespace display_server; class DSPointerTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSPointerTest, NewDSPointerWithDSSeat) diff --git a/tests/DSPolicyArea-test.cpp b/tests/DSPolicyArea-test.cpp index cc106ff..af945c9 100644 --- a/tests/DSPolicyArea-test.cpp +++ b/tests/DSPolicyArea-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSPolicyAreaTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSPolicyAreaTest, NewDSPolicyArea) diff --git a/tests/DSProperty-test.cpp b/tests/DSProperty-test.cpp index caaa2ca..85ae4f1 100644 --- a/tests/DSProperty-test.cpp +++ b/tests/DSProperty-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSPropertyTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSPropertyTest, CreateProperty) diff --git a/tests/DSRefBase-test.cpp b/tests/DSRefBase-test.cpp index 26952be..f5198e9 100644 --- a/tests/DSRefBase-test.cpp +++ b/tests/DSRefBase-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSRefBaseTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSRefBaseTest, CreateRefBase) diff --git a/tests/DSRenderEngineDaliImpl-test.cpp b/tests/DSRenderEngineDaliImpl-test.cpp index f3e6143..d794532 100644 --- a/tests/DSRenderEngineDaliImpl-test.cpp +++ b/tests/DSRenderEngineDaliImpl-test.cpp @@ -59,7 +59,8 @@ public: __eventLoop->run(); - setenv("XDG_RUNTIME_DIR", "/run", 1); + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); setenv("TBM_DISPLAY_SERVER", "1", 1); } void TearDown(void) override diff --git a/tests/DSRenderEngineEcoreEvasImpl-test.cpp b/tests/DSRenderEngineEcoreEvasImpl-test.cpp index ff917fd..4b93a28 100644 --- a/tests/DSRenderEngineEcoreEvasImpl-test.cpp +++ b/tests/DSRenderEngineEcoreEvasImpl-test.cpp @@ -31,10 +31,15 @@ using namespace display_server; class DSRenderEngineEcoreEvasTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSRenderEngineEcoreEvasTest, RenderEngine_Create) diff --git a/tests/DSSeat-test.cpp b/tests/DSSeat-test.cpp index 03a4190..e20da03 100644 --- a/tests/DSSeat-test.cpp +++ b/tests/DSSeat-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSSeatTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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"); + } }; class MockCompositor : public DSCompositor diff --git a/tests/DSSignal-test.cpp b/tests/DSSignal-test.cpp index b37fe21..02db211 100644 --- a/tests/DSSignal-test.cpp +++ b/tests/DSSignal-test.cpp @@ -30,10 +30,15 @@ using namespace display_server; class DSSignalTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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"); + } }; class SenderMock : public DSObject diff --git a/tests/DSSignalBroker-test.cpp b/tests/DSSignalBroker-test.cpp index 4484885..644cc27 100644 --- a/tests/DSSignalBroker-test.cpp +++ b/tests/DSSignalBroker-test.cpp @@ -192,10 +192,15 @@ public: class DSSignalBrokerTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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"); + } }; std::shared_ptr __receiver; @@ -284,4 +289,4 @@ TEST_F(DSSignalBrokerTest, emitMultiItems) // 4. see Changes EXPECT_TRUE(receiver->result3 == "Test"); -} \ No newline at end of file +} diff --git a/tests/DSTextInput-test.cpp b/tests/DSTextInput-test.cpp index 721f0f3..55ba75d 100644 --- a/tests/DSTextInput-test.cpp +++ b/tests/DSTextInput-test.cpp @@ -29,14 +29,15 @@ using namespace display_server; class DSTextInputTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSTizenAppinfo-test.cpp b/tests/DSTizenAppinfo-test.cpp index b893611..2b2b7bc 100644 --- a/tests/DSTizenAppinfo-test.cpp +++ b/tests/DSTizenAppinfo-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSTizenAppinfoTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSTizenAppinfoTest, NewTizenAppinfo) diff --git a/tests/DSTouch-test.cpp b/tests/DSTouch-test.cpp index 870cedf..ec62871 100644 --- a/tests/DSTouch-test.cpp +++ b/tests/DSTouch-test.cpp @@ -34,14 +34,15 @@ using namespace display_server; class DSTouchTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSTouchTest, NewDSTouchWithDSSeat) diff --git a/tests/DSTraceInfo-test.cpp b/tests/DSTraceInfo-test.cpp index e382c2e..5d99ebb 100644 --- a/tests/DSTraceInfo-test.cpp +++ b/tests/DSTraceInfo-test.cpp @@ -29,14 +29,15 @@ using namespace display_server; class DSTraceInfoTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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(DSTraceInfoTest, NewTraceInfo) diff --git a/tests/DSWaylandBuffer-test.cpp b/tests/DSWaylandBuffer-test.cpp index 850bc52..e0e2fcd 100644 --- a/tests/DSWaylandBuffer-test.cpp +++ b/tests/DSWaylandBuffer-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandBufferTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandBufferTest, NewDSWaylandBuffer) diff --git a/tests/DSWaylandCallback-test.cpp b/tests/DSWaylandCallback-test.cpp index d44a541..9c7a0e3 100644 --- a/tests/DSWaylandCallback-test.cpp +++ b/tests/DSWaylandCallback-test.cpp @@ -30,9 +30,14 @@ class DSWaylandCallbackTest : public ::testing::Test { public: 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(DSWaylandCallbackTest, NewDSWaylandCallback) diff --git a/tests/DSWaylandClient-test.cpp b/tests/DSWaylandClient-test.cpp index 7c6625a..e08707f 100644 --- a/tests/DSWaylandClient-test.cpp +++ b/tests/DSWaylandClient-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSWaylandClientTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandCompositor-test.cpp b/tests/DSWaylandCompositor-test.cpp index 7d0a735..c2bf133 100644 --- a/tests/DSWaylandCompositor-test.cpp +++ b/tests/DSWaylandCompositor-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSWaylandCompositorTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandExtension-test.cpp b/tests/DSWaylandExtension-test.cpp index c73aa79..eb9388e 100644 --- a/tests/DSWaylandExtension-test.cpp +++ b/tests/DSWaylandExtension-test.cpp @@ -31,10 +31,15 @@ using namespace display_server; class DSWaylandExtensionTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandExtensionTest, NewWaylandExtension) diff --git a/tests/DSWaylandInputMethod-test.cpp b/tests/DSWaylandInputMethod-test.cpp index 152b953..98aeae4 100644 --- a/tests/DSWaylandInputMethod-test.cpp +++ b/tests/DSWaylandInputMethod-test.cpp @@ -31,7 +31,8 @@ class DSWaylandInputMethodTest : public ::testing::Test public: void SetUp(void) override { - setenv("XDG_RUNTIME_DIR", "/run", 1); + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); } void TearDown(void) override { diff --git a/tests/DSWaylandInputMethodContext-test.cpp b/tests/DSWaylandInputMethodContext-test.cpp index 6b2808e..ec2d51b 100644 --- a/tests/DSWaylandInputMethodContext-test.cpp +++ b/tests/DSWaylandInputMethodContext-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSWaylandInputMethodContextTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandInputPanel-test.cpp b/tests/DSWaylandInputPanel-test.cpp index 04d72a2..b367486 100644 --- a/tests/DSWaylandInputPanel-test.cpp +++ b/tests/DSWaylandInputPanel-test.cpp @@ -29,14 +29,15 @@ using namespace display_server; class DSWaylandInputPanelTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandInputPanelSurface-test.cpp b/tests/DSWaylandInputPanelSurface-test.cpp index c6ee3e1..3de9fa2 100644 --- a/tests/DSWaylandInputPanelSurface-test.cpp +++ b/tests/DSWaylandInputPanelSurface-test.cpp @@ -29,14 +29,15 @@ using namespace display_server; class DSWaylandInputPanelSurfaceTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandKeyboard-test.cpp b/tests/DSWaylandKeyboard-test.cpp index 2cac0bf..4146bcf 100644 --- a/tests/DSWaylandKeyboard-test.cpp +++ b/tests/DSWaylandKeyboard-test.cpp @@ -33,7 +33,8 @@ class DSWaylandKeyboardTest : public ::testing::Test public: void SetUp(void) override { - setenv("XDG_RUNTIME_DIR", "/run", 1); + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); } void TearDown(void) override { diff --git a/tests/DSWaylandOutput-test.cpp b/tests/DSWaylandOutput-test.cpp index 9794705..0009b60 100644 --- a/tests/DSWaylandOutput-test.cpp +++ b/tests/DSWaylandOutput-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandOutputTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandOutputTest, NewDSWaylandOutput) diff --git a/tests/DSWaylandPointer-test.cpp b/tests/DSWaylandPointer-test.cpp index 119b16b..05cf9c0 100644 --- a/tests/DSWaylandPointer-test.cpp +++ b/tests/DSWaylandPointer-test.cpp @@ -31,14 +31,15 @@ using namespace display_server; class DSWaylandPointerTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandProtocolTrace-test.cpp b/tests/DSWaylandProtocolTrace-test.cpp index a7d3b6f..c5451ce 100644 --- a/tests/DSWaylandProtocolTrace-test.cpp +++ b/tests/DSWaylandProtocolTrace-test.cpp @@ -29,19 +29,19 @@ using namespace display_server; class DSWaylandProtocolTraceTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - setenv("E_INFO_RULE_FILE", "/tmp/rule", 1); - setenv("E_INFO_TRACE_FILE", "/tmp/trace", 1); - } - void TearDown(void) override - { - unsetenv("XDG_RUNTIME_DIR"); - unsetenv("E_INFO_RULE_FILE"); - unsetenv("E_INFO_TRACE_FILE"); - } - + void SetUp(void) override + { + char *xdir = getenv("DEFAULT_XDG_RUNTIME_DIR"); + setenv("XDG_RUNTIME_DIR", xdir, 1); + setenv("E_INFO_RULE_FILE", "/tmp/rule", 1); + setenv("E_INFO_TRACE_FILE", "/tmp/trace", 1); + } + void TearDown(void) override + { + unsetenv("XDG_RUNTIME_DIR"); + unsetenv("E_INFO_RULE_FILE"); + unsetenv("E_INFO_TRACE_FILE"); + } }; TEST_F(DSWaylandProtocolTraceTest, NewDSWaylandProtocolTrace) @@ -146,4 +146,4 @@ TEST_F(DSWaylandProtocolTraceTest, DSWaylandProtocolTraceEnableTraceTrue) EXPECT_TRUE(pTrace->enableProtocolTrace(trace_state) == 1); DSWaylandProtocolTrace::releaseInstance(); } -} \ No newline at end of file +} diff --git a/tests/DSWaylandSeat-test.cpp b/tests/DSWaylandSeat-test.cpp index 8d2f000..06f67b7 100644 --- a/tests/DSWaylandSeat-test.cpp +++ b/tests/DSWaylandSeat-test.cpp @@ -32,14 +32,15 @@ using namespace display_server; class DSWaylandSeatTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandSurface-test.cpp b/tests/DSWaylandSurface-test.cpp index a83794b..a83d794 100644 --- a/tests/DSWaylandSurface-test.cpp +++ b/tests/DSWaylandSurface-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSWaylandSurfaceTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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"); + } }; static void diff --git a/tests/DSWaylandTextInput-test.cpp b/tests/DSWaylandTextInput-test.cpp index 5a3e18e..4dd5414 100644 --- a/tests/DSWaylandTextInput-test.cpp +++ b/tests/DSWaylandTextInput-test.cpp @@ -30,14 +30,15 @@ using namespace display_server; class DSWaylandTextInputTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandTextInputManager-test.cpp b/tests/DSWaylandTextInputManager-test.cpp index abca02b..03e34dd 100644 --- a/tests/DSWaylandTextInputManager-test.cpp +++ b/tests/DSWaylandTextInputManager-test.cpp @@ -29,14 +29,15 @@ using namespace display_server; class DSWaylandTextInputManagerTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandTizenAppinfo-test.cpp b/tests/DSWaylandTizenAppinfo-test.cpp index 212700d..8589a32 100644 --- a/tests/DSWaylandTizenAppinfo-test.cpp +++ b/tests/DSWaylandTizenAppinfo-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenAppinfoTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenAppinfoTest, New_Appinfo) diff --git a/tests/DSWaylandTizenIndicator-test.cpp b/tests/DSWaylandTizenIndicator-test.cpp index 50df9de..2f3c4eb 100644 --- a/tests/DSWaylandTizenIndicator-test.cpp +++ b/tests/DSWaylandTizenIndicator-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenIndicatorTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenIndicatorTest, NewDSWaylandTizenIndicator) diff --git a/tests/DSWaylandTizenInputDevice-test.cpp b/tests/DSWaylandTizenInputDevice-test.cpp index 5ebd223..8ca5d0a 100644 --- a/tests/DSWaylandTizenInputDevice-test.cpp +++ b/tests/DSWaylandTizenInputDevice-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenInputDeviceTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenInputDeviceTest, NewDSWaylandTizenInputDevice) diff --git a/tests/DSWaylandTizenInputDeviceManager-test.cpp b/tests/DSWaylandTizenInputDeviceManager-test.cpp index aa437c7..09836aa 100644 --- a/tests/DSWaylandTizenInputDeviceManager-test.cpp +++ b/tests/DSWaylandTizenInputDeviceManager-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenInputDeviceManagerTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenInputDeviceManagerTest, NewDSWaylandTizenInputDeviceManager) diff --git a/tests/DSWaylandTizenLaunchEffect-test.cpp b/tests/DSWaylandTizenLaunchEffect-test.cpp index 6a1eecd..14ed80a 100644 --- a/tests/DSWaylandTizenLaunchEffect-test.cpp +++ b/tests/DSWaylandTizenLaunchEffect-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenLaunchEffectTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenLaunchEffectTest, New_LaunchEffect) @@ -61,4 +66,4 @@ TEST_F(DSWaylandTizenLaunchEffectTest, Initialize_LaunchEffect) delete tzLaunchEffect; DSWaylandCompositor::releaseInstance(); -} \ No newline at end of file +} diff --git a/tests/DSWaylandTizenPolicy-test.cpp b/tests/DSWaylandTizenPolicy-test.cpp index 81e5839..27ab7df 100644 --- a/tests/DSWaylandTizenPolicy-test.cpp +++ b/tests/DSWaylandTizenPolicy-test.cpp @@ -30,10 +30,15 @@ using namespace display_server; class DSWaylandTizenPolicyTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenPolicyTest, new_P1) diff --git a/tests/DSWaylandTizenPolicyExt-test.cpp b/tests/DSWaylandTizenPolicyExt-test.cpp index f5868e3..0f27e06 100644 --- a/tests/DSWaylandTizenPolicyExt-test.cpp +++ b/tests/DSWaylandTizenPolicyExt-test.cpp @@ -30,9 +30,14 @@ class DSWaylandTizenPolicyExtTest : public ::testing::Test { public: 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(DSWaylandTizenPolicyExtTest, NewDSWaylandTizenPolicyExt) diff --git a/tests/DSWaylandTizenSurface-test.cpp b/tests/DSWaylandTizenSurface-test.cpp index b4d04c7..ec979e4 100644 --- a/tests/DSWaylandTizenSurface-test.cpp +++ b/tests/DSWaylandTizenSurface-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenSurfaceTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenSurfaceTest, NewDSWaylandTizenSurface) diff --git a/tests/DSWaylandTizenSurfaceShm-test.cpp b/tests/DSWaylandTizenSurfaceShm-test.cpp index 6471826..4579b4c 100644 --- a/tests/DSWaylandTizenSurfaceShm-test.cpp +++ b/tests/DSWaylandTizenSurfaceShm-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSWaylandTizenSurfaceShmTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWaylandTizenSurfaceShmTest, NewDSWaylandTizenSurfaceShm) diff --git a/tests/DSWaylandTouch-test.cpp b/tests/DSWaylandTouch-test.cpp index 60a2c46..a7c8a14 100644 --- a/tests/DSWaylandTouch-test.cpp +++ b/tests/DSWaylandTouch-test.cpp @@ -31,14 +31,15 @@ using namespace display_server; class DSWaylandTouchTest : public ::testing::Test { public: - void SetUp(void) override - { - setenv("XDG_RUNTIME_DIR", "/run", 1); - } - void TearDown(void) override - { - 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 cases */ diff --git a/tests/DSWaylandZxdgShellV6-test.cpp b/tests/DSWaylandZxdgShellV6-test.cpp index aae14f2..593bbc0 100644 --- a/tests/DSWaylandZxdgShellV6-test.cpp +++ b/tests/DSWaylandZxdgShellV6-test.cpp @@ -30,9 +30,14 @@ class DSWaylandZxdgShellV6Test : public ::testing::Test { public: 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(DSWaylandZxdgShellV6Test, NewDSWaylandZxdgShellV6) diff --git a/tests/DSWindow-test.cpp b/tests/DSWindow-test.cpp index 1ac52c9..d0f7695 100644 --- a/tests/DSWindow-test.cpp +++ b/tests/DSWindow-test.cpp @@ -32,10 +32,15 @@ using namespace display_server; class DSWindowTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWindowTest, NewDSWindow) diff --git a/tests/DSWindowManager-test.cpp b/tests/DSWindowManager-test.cpp index 319d418..cc3de04 100644 --- a/tests/DSWindowManager-test.cpp +++ b/tests/DSWindowManager-test.cpp @@ -36,15 +36,18 @@ DSWindowManager* g_winMgr = nullptr; class DSWindowManagerTest : public ::testing::Test { public: - void SetUp(void) override - { + 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 - { + } + void TearDown(void) override + { DSWindowManager::releaseInstance(); g_winMgr = nullptr; - } + unsetenv("XDG_RUNTIME_DIR"); + } }; TEST_F(DSWindowManagerTest, GetWindowManager) diff --git a/tests/DSWindowShell-test.cpp b/tests/DSWindowShell-test.cpp index 43ce069..bb5b3a7 100644 --- a/tests/DSWindowShell-test.cpp +++ b/tests/DSWindowShell-test.cpp @@ -34,10 +34,15 @@ using namespace display_server; class DSWindowShellTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSWindowShellTest, NewDSWindowShell) diff --git a/tests/DSXkb-test.cpp b/tests/DSXkb-test.cpp index c57d66a..b28c036 100644 --- a/tests/DSXkb-test.cpp +++ b/tests/DSXkb-test.cpp @@ -29,10 +29,15 @@ using namespace display_server; class DSXkbTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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(DSXkbTest, NewDSXkb) diff --git a/tests/DSZone-test.cpp b/tests/DSZone-test.cpp index 83a685b..7e69b18 100644 --- a/tests/DSZone-test.cpp +++ b/tests/DSZone-test.cpp @@ -33,10 +33,15 @@ using namespace display_server; class DSZoneTest : public ::testing::Test { public: - void SetUp(void) override - {} - void TearDown(void) override - {} + 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"); + } }; class TestZone : public DSObject diff --git a/tests/libds-tests.cpp b/tests/libds-tests.cpp index 4a9ed5a..6446522 100644 --- a/tests/libds-tests.cpp +++ b/tests/libds-tests.cpp @@ -32,6 +32,7 @@ int main(int argc, char **argv) #ifdef TIZEN_TEST_GCOV setenv("GCOV_PREFIX", "/tmp", 1); #endif + setenv("DEFAULT_XDG_RUNTIME_DIR", "/tmp", 1); try { ::testing::InitGoogleMock(&argc, argv); -- 2.7.4 From 1389ee30f4f6ac4c36b5590e3634a41304d8f689 Mon Sep 17 00:00:00 2001 From: jeon Date: Tue, 1 Sep 2020 20:38:56 +0900 Subject: [PATCH 05/16] tests: set DSWaylandSurface to DSWindow Change-Id: I6b8fe90cca56a5808dd71d9db264489301ee7055 --- tests/DSKeyboard-test.cpp | 6 ++++++ tests/DSPointer-test.cpp | 6 ++++++ tests/DSTouch-test.cpp | 6 ++++++ 3 files changed, 18 insertions(+) diff --git a/tests/DSKeyboard-test.cpp b/tests/DSKeyboard-test.cpp index 94aa630..fe08c28 100644 --- a/tests/DSKeyboard-test.cpp +++ b/tests/DSKeyboard-test.cpp @@ -28,6 +28,7 @@ #include "DSWaylandSeat.h" #include "DSWaylandCompositor.h" #include "DSWindow.h" +#include "DSWaylandSurface.h" using namespace display_server; @@ -94,6 +95,11 @@ TEST_F(DSKeyboardTest, BasicMethods) auto window = std::make_shared(); EXPECT_TRUE(window != nullptr); + auto waylandSurface = std::make_shared(); + EXPECT_TRUE(waylandSurface != nullptr); + + window->create(waylandSurface); + if (seat && window) { auto keyboard = new DSKeyboard(seat); diff --git a/tests/DSPointer-test.cpp b/tests/DSPointer-test.cpp index d482d8a..10b18dd 100644 --- a/tests/DSPointer-test.cpp +++ b/tests/DSPointer-test.cpp @@ -28,6 +28,7 @@ #include "DSWaylandSeat.h" #include "DSWaylandCompositor.h" #include "DSWindow.h" +#include "DSWaylandSurface.h" using namespace display_server; @@ -94,6 +95,11 @@ TEST_F(DSPointerTest, BasicMethods) auto window = std::make_shared(); EXPECT_TRUE(window != nullptr); + auto waylandSurface = std::make_shared(); + EXPECT_TRUE(waylandSurface != nullptr); + + window->create(waylandSurface); + if (seat && window) { auto pointer = new DSPointer(seat); diff --git a/tests/DSTouch-test.cpp b/tests/DSTouch-test.cpp index ec62871..a9b476e 100644 --- a/tests/DSTouch-test.cpp +++ b/tests/DSTouch-test.cpp @@ -28,6 +28,7 @@ #include "DSWaylandSeat.h" #include "DSWaylandCompositor.h" #include "DSWindow.h" +#include "DSWaylandSurface.h" using namespace display_server; @@ -94,6 +95,11 @@ TEST_F(DSTouchTest, BasicMethods) auto window = std::make_shared(); EXPECT_TRUE(window != nullptr); + auto waylandSurface = std::make_shared(); + EXPECT_TRUE(waylandSurface != nullptr); + + window->create(waylandSurface); + if (seat && window) { auto touch = new DSTouch(seat); -- 2.7.4 From 486e5d53518bcf98b5f50509927b11779bc23529 Mon Sep 17 00:00:00 2001 From: jeon Date: Tue, 1 Sep 2020 21:47:19 +0900 Subject: [PATCH 06/16] tests: set nullptr to focus for test DSWaylandKeyboard temporary Change-Id: I38a5cc4b650ac1fab42e7b8027730139b6a1e1fb --- tests/DSWaylandKeyboard-test.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/DSWaylandKeyboard-test.cpp b/tests/DSWaylandKeyboard-test.cpp index 4146bcf..3254f4f 100644 --- a/tests/DSWaylandKeyboard-test.cpp +++ b/tests/DSWaylandKeyboard-test.cpp @@ -105,8 +105,13 @@ TEST_F(DSWaylandKeyboardTest, SetGetFocus) if (waylandSurface) { - keyboard->setFocus(waylandSurface.get()); - EXPECT_TRUE(waylandSurface.get() == keyboard->getFocus()); + /* FIXME: currently we cannot create wl_surface so setFocus will be always set nullptr to focus + * so temporary I set nullptr to focus for test but this will be fixed + * keyboard->setFocus(waylandSurface.get()); + * EXPECT_TRUE(waylandSurface.get() == keyboard->getFocus()); + */ + keyboard->setFocus(nullptr); + EXPECT_TRUE(nullptr == keyboard->getFocus()); } } } -- 2.7.4 From 13acba18dd973e99adc66a180342f0e66aa59b9f Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Wed, 2 Sep 2020 10:15:28 +0900 Subject: [PATCH 07/16] DSWaylandTizenPolicy: initialize member variable Change-Id: I00e9c371c6a7fe91746af2b9166062bd82be97fd --- src/DSWaylandServer/DSWaylandTizenPolicy.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/DSWaylandServer/DSWaylandTizenPolicy.cpp b/src/DSWaylandServer/DSWaylandTizenPolicy.cpp index 6b0f1fa..0e7ba7f 100644 --- a/src/DSWaylandServer/DSWaylandTizenPolicy.cpp +++ b/src/DSWaylandServer/DSWaylandTizenPolicy.cpp @@ -365,7 +365,8 @@ void DSWaylandTizenPolicyPrivate::tizen_policy_set_appid(Resource *resource, int DSWaylandTizenPolicy::DSWaylandTizenPolicy(DSWaylandCompositor *wlCompositor) : DS_INIT_PRIVATE_PTR(DSWaylandTizenPolicy), - __wlCompositor(wlCompositor) + __wlCompositor(wlCompositor), + __isCreated(false) { this->initialize(__wlCompositor); } -- 2.7.4 From 65e83e1da1a8f9dd281032852375158ff2597eb0 Mon Sep 17 00:00:00 2001 From: Sung-Jin Park Date: Wed, 2 Sep 2020 10:36:28 +0900 Subject: [PATCH 08/16] tests: enable setting DEFAULT_XDG_RUNTIME_DIR environment variable Change-Id: I77d4b07286501ba296affb4a3eb918f2a642545b Signed-off-by: Sung-Jin Park --- tests/libds-tests.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/libds-tests.cpp b/tests/libds-tests.cpp index 6446522..1fd6b75 100644 --- a/tests/libds-tests.cpp +++ b/tests/libds-tests.cpp @@ -27,12 +27,16 @@ int main(int argc, char **argv) { + char *strEnv = nullptr; auto AllTestSuccess = false; #ifdef TIZEN_TEST_GCOV setenv("GCOV_PREFIX", "/tmp", 1); #endif - setenv("DEFAULT_XDG_RUNTIME_DIR", "/tmp", 1); + strEnv = getenv("DEFAULT_XDG_RUNTIME_DIR"); + if (!strEnv) { + setenv("DEFAULT_XDG_RUNTIME_DIR", "/tmp", 1); + } try { ::testing::InitGoogleMock(&argc, argv); -- 2.7.4 From a9772b4763520538a6c7a998969cf3faec2f2c1a Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Wed, 2 Sep 2020 10:18:48 +0900 Subject: [PATCH 09/16] DSWaylandTizenAppinfo: call DSTizenAppinfoMgr::releaseInstance only when it gets DSTizenAppinfoManager::getInstance() Change-Id: Ie3641285c8965d7925f51b7d4bfc3890697cf02f --- src/DSWaylandServer/DSWaylandTizenAppinfo.cpp | 8 +++++++- src/DSWaylandServer/DSWaylandTizenAppinfo.h | 1 + 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/DSWaylandServer/DSWaylandTizenAppinfo.cpp b/src/DSWaylandServer/DSWaylandTizenAppinfo.cpp index 8f4a684..c78681d 100644 --- a/src/DSWaylandServer/DSWaylandTizenAppinfo.cpp +++ b/src/DSWaylandServer/DSWaylandTizenAppinfo.cpp @@ -123,16 +123,19 @@ void DSWaylandTizenAppinfoPrivate::tizen_launch_appinfo_ready_metadata(Resource DSWaylandTizenAppinfo::DSWaylandTizenAppinfo(DSWaylandCompositor *wlCompositor) : DS_INIT_PRIVATE_PTR(DSWaylandTizenAppinfo), __wlCompositor(wlCompositor), - __isCreated(false) + __isCreated(false), + __isGetDSTizenAppinfoMgr(false) { this->initialize(__wlCompositor); __dsAppinfoMgr = DSTizenAppinfoMgr::getInstance(); + __isGetDSTizenAppinfoMgr = true; } DSWaylandTizenAppinfo::DSWaylandTizenAppinfo(DSWaylandCompositor *wlCompositor, DSTizenAppinfoMgr *dsAppinfoMgr) : DS_INIT_PRIVATE_PTR(DSWaylandTizenAppinfo), __wlCompositor(wlCompositor), __isCreated(false), + __isGetDSTizenAppinfoMgr(false), __dsAppinfoMgr(dsAppinfoMgr) { this->initialize(__wlCompositor); @@ -140,6 +143,9 @@ DSWaylandTizenAppinfo::DSWaylandTizenAppinfo(DSWaylandCompositor *wlCompositor, DSWaylandTizenAppinfo::~DSWaylandTizenAppinfo() { + if (__isGetDSTizenAppinfoMgr) + DSTizenAppinfoMgr::releaseInstance(); + if (isCreated()) this->finalize(); } diff --git a/src/DSWaylandServer/DSWaylandTizenAppinfo.h b/src/DSWaylandServer/DSWaylandTizenAppinfo.h index ae3691b..f11b122 100644 --- a/src/DSWaylandServer/DSWaylandTizenAppinfo.h +++ b/src/DSWaylandServer/DSWaylandTizenAppinfo.h @@ -51,6 +51,7 @@ public: private: DSWaylandCompositor *__wlCompositor; bool __isCreated; + bool __isGetDSTizenAppinfoMgr; DSTizenAppinfoMgr *__dsAppinfoMgr; }; -- 2.7.4 From a7f0beb80ca73fdc7988bd8df33b2c91fc4046b7 Mon Sep 17 00:00:00 2001 From: dyamy-lee Date: Wed, 2 Sep 2020 13:48:38 +0900 Subject: [PATCH 10/16] DSWaylandProtocolTrace : Add LOCV_EXCL Change-Id: Ibd5eefc81487bcaafd573ea269abcb607a65217a --- src/DSWaylandServer/DSWaylandProtocolTrace.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/DSWaylandServer/DSWaylandProtocolTrace.cpp b/src/DSWaylandServer/DSWaylandProtocolTrace.cpp index 75d8583..b6575c8 100644 --- a/src/DSWaylandServer/DSWaylandProtocolTrace.cpp +++ b/src/DSWaylandServer/DSWaylandProtocolTrace.cpp @@ -29,7 +29,7 @@ namespace display_server { - +/*LCOV_EXCL_START*/ int DSWaylandProtocolTrace::__refCount { 0 }; std::mutex DSWaylandProtocolTrace::__mutex; DSWaylandProtocolTrace* DSWaylandProtocolTrace::__protocolTrace { nullptr }; @@ -1490,5 +1490,5 @@ int DSWaylandProtocolTracePrivate::rule_validate_func(ProtocolTrace_Tree *tree, } return 0; } - +/*LCOV_EXCL_STOP*/ } // namespace display_server \ No newline at end of file -- 2.7.4 From 44bb25fa56337205175ed323137a9de16947dd6d Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Wed, 2 Sep 2020 15:27:57 +0900 Subject: [PATCH 11/16] DSWindowManager: modify setWindowParent API Change-Id: Ib7a361b2f568aa3f234e8712b8d1fae107893eb3 --- src/DSWindowManager/DSWindowManager.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/DSWindowManager/DSWindowManager.cpp b/src/DSWindowManager/DSWindowManager.cpp index a77dcce..7ee3873 100644 --- a/src/DSWindowManager/DSWindowManager.cpp +++ b/src/DSWindowManager/DSWindowManager.cpp @@ -207,8 +207,11 @@ bool DSWindowManagerPrivate::setWindowParent(DSWaylandSurface *dswlSurface, DSWa DSZone *zone = __getZone(dswlSurface); if (!zone) return false; - DSZone *pZone = __getZone(dswlParentSurface); - if (zone != pZone) return false; + if (dswlParentSurface) + { + DSZone *pZone = __getZone(dswlParentSurface); + if (zone != pZone) return false; + } return zone->setWindowParent(dswlSurface, dswlParentSurface); } -- 2.7.4 From b7e6fb69d1a012144c7f4ca4bb07f0b7c423fa21 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Wed, 2 Sep 2020 15:28:44 +0900 Subject: [PATCH 12/16] DSZone: modify testCreateWindow function Change-Id: I0ce2d001309f9a62db10b9a067bf00918f97c767 --- src/DSZone/DSZone.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/DSZone/DSZone.cpp b/src/DSZone/DSZone.cpp index 610e872..eedc406 100644 --- a/src/DSZone/DSZone.cpp +++ b/src/DSZone/DSZone.cpp @@ -235,10 +235,11 @@ void DSZone::callCallbackWindowShellCreated(std::shared_ptr winSh bool DSZone::testCreateWindow(std::shared_ptr waylandSurface) { - std::shared_ptr window = __createWindow(waylandSurface); - if (!window) return false; + if (waylandSurface == nullptr) + return false; - return true; + __onSurfaceCreated(waylandSurface); + return true; } std::list> DSZone::getWindowList() -- 2.7.4 From 8060858cbd0a62bc2c29d356064268de83117ecc Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Wed, 2 Sep 2020 15:29:17 +0900 Subject: [PATCH 13/16] DSWindowManager: add TCs Change-Id: If005e3d9b2b5151fca6d5b30af68aa00e28f5fc8 --- tests/DSWindowManager-test.cpp | 384 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 357 insertions(+), 27 deletions(-) diff --git a/tests/DSWindowManager-test.cpp b/tests/DSWindowManager-test.cpp index cc3de04..43f5d02 100644 --- 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(); EXPECT_TRUE(zone != nullptr); @@ -68,19 +66,21 @@ TEST_F(DSWindowManagerTest, RegisterWindow) auto window = std::make_shared(); 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(); EXPECT_TRUE(zone != nullptr); @@ -96,19 +97,348 @@ TEST_F(DSWindowManagerTest, RegisterSurface) auto surface = std::make_shared(); 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface = std::make_shared(); + EXPECT_TRUE(surface != nullptr); + + auto surface2 = std::make_shared(); + 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(); + EXPECT_TRUE(zone != nullptr); + + auto zone2 = std::make_shared(); + EXPECT_TRUE(zone2 != nullptr); + + auto surface = std::make_shared(); + EXPECT_TRUE(surface != nullptr); + + auto surface2 = std::make_shared(); + 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface = std::make_shared(); + 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> 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface = std::make_shared(); + 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 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface0 = std::make_shared(); + EXPECT_TRUE(surface0 != nullptr); + DSWaylandSurface *surface_ptr0 = surface0.get(); + EXPECT_TRUE(surface_ptr0 != nullptr); + + auto surface1 = std::make_shared(); + EXPECT_TRUE(surface1 != nullptr); + DSWaylandSurface *surface_ptr1 = surface1.get(); + EXPECT_TRUE(surface_ptr1 != nullptr); + + auto surface2 = std::make_shared(); + 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> 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface = std::make_shared(); + 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> 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(); + EXPECT_TRUE(zone != nullptr); + + auto surface = std::make_shared(); + 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); +} -- 2.7.4 From 88099be79f859220177914c2eff0b415ff746e16 Mon Sep 17 00:00:00 2001 From: Joonbum Ko Date: Wed, 2 Sep 2020 14:34:31 +0900 Subject: [PATCH 14/16] DSRenderEngineDaliImpl-test: Added TC to improve coverage Change-Id: Ib352a858d48172c6a18a20a077c4640bf99e227e Signed-off-by: Joonbum Ko --- tests/DSRenderEngineDaliImpl-test.cpp | 239 ++++++++++++++++++++++++++++++++++ 1 file changed, 239 insertions(+) diff --git a/tests/DSRenderEngineDaliImpl-test.cpp b/tests/DSRenderEngineDaliImpl-test.cpp index d794532..001fc8a 100644 --- a/tests/DSRenderEngineDaliImpl-test.cpp +++ b/tests/DSRenderEngineDaliImpl-test.cpp @@ -290,3 +290,242 @@ TEST_F(DSRenderEngineDaliTest, RenderEngine_ComposeTwoRenderView) usleep(1000000); } } + +TEST_F(DSRenderEngineDaliTest, RenderEngine_RaiseToTop) +{ + std::unique_ptr displayDevice = std::make_unique(); + std::list> outputList = displayDevice->getOutputList(); + EXPECT_TRUE(outputList.size() != 0); + + IDSDisplayDeviceOutput::ConnectorType connType; + IDSDisplayDeviceOutput::ConnectState connState; + std::shared_ptr deviceHWC; + + for (std::shared_ptr output : outputList) { + connType = output->getConnectType(); + EXPECT_TRUE(connType <= IDSDisplayDeviceOutput::TYPE_DSI); + connState = output->getConnectState(); + EXPECT_TRUE(connState <= IDSDisplayDeviceOutput::STATE_MODESET); + if (connState == IDSDisplayDeviceOutput::STATE_DISCONNECTED) + continue; + + auto bestMode = (output->getAvailableModes()).front(); + EXPECT_TRUE(output->setMode(bestMode) == true); + EXPECT_TRUE(output->getMode() == bestMode); + + deviceHWC = output->getHWC(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto bufferQueue = deviceHWC->getTargetBufferQueue(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto renderEngine = std::make_unique(bufferQueue); + EXPECT_TRUE(renderEngine != nullptr); + + int imgWidth = 500; + int imgHeight = 500; + + // for 1st renderView -- begin -- + auto renderViewA = renderEngine->makeRenderView(); + EXPECT_TRUE(renderViewA != nullptr); + + // create RED image buffer + tbm_surface_h tbmTextureA = DSRenderEngineDaliTest::createTbmTexture( + imgWidth, imgHeight, 255, 0, 0, 255); + EXPECT_TRUE(tbmTextureA != nullptr); + + auto imageSourceBufferA = std::make_shared (imgWidth, imgHeight, IDSBuffer::FORMAT_ARGB8888, tbmTextureA); + EXPECT_TRUE(renderViewA->setBuffer(imageSourceBufferA)); + // -- end -- + + // for 2nd renderView -- begin -- + auto renderViewB = renderEngine->makeRenderView(); + EXPECT_TRUE(renderViewB != nullptr); + + // The buffer size of the second renderView is half of the first. + // create BLUE image buffer + tbm_surface_h tbmTextureB = DSRenderEngineDaliTest::createTbmTexture( + imgWidth/2, imgHeight/2, 0, 0, 255, 255); + EXPECT_TRUE(tbmTextureB != nullptr); + + auto imageSourceBufferB = std::make_shared (imgWidth/2, imgHeight/2, IDSBuffer::FORMAT_ARGB8888, tbmTextureB); + EXPECT_TRUE(renderViewB->setBuffer(imageSourceBufferB)); + // -- end -- + + // raise renderViewA to Top + renderViewA->raiseToTop(); + + EXPECT_TRUE(renderEngine->renderFrame()); + + /* + * Since renderViewA was created and added before renderViewB, + * renderViewB should be drawn above and renderViewA below. + * But because renderViewA called raiseToTop(), A rises up and covers B. + * + * ┌─────────────┐ + * │ │ + * │ A │ + * │ │ + * │ red │ + * │ 　 │ + * └─────────────┘ + */ + + usleep(1000000); + + EXPECT_TRUE(bufferQueue->canAcquireBuffer(true)); + + // commit + EXPECT_TRUE(deviceHWC->commit()); + + usleep(1000000); + } +} + +TEST_F(DSRenderEngineDaliTest, RenderEngine_LowerToBottom) +{ + std::unique_ptr displayDevice = std::make_unique(); + std::list> outputList = displayDevice->getOutputList(); + EXPECT_TRUE(outputList.size() != 0); + + IDSDisplayDeviceOutput::ConnectorType connType; + IDSDisplayDeviceOutput::ConnectState connState; + std::shared_ptr deviceHWC; + + for (std::shared_ptr output : outputList) { + connType = output->getConnectType(); + EXPECT_TRUE(connType <= IDSDisplayDeviceOutput::TYPE_DSI); + connState = output->getConnectState(); + EXPECT_TRUE(connState <= IDSDisplayDeviceOutput::STATE_MODESET); + if (connState == IDSDisplayDeviceOutput::STATE_DISCONNECTED) + continue; + + auto bestMode = (output->getAvailableModes()).front(); + EXPECT_TRUE(output->setMode(bestMode) == true); + EXPECT_TRUE(output->getMode() == bestMode); + + deviceHWC = output->getHWC(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto bufferQueue = deviceHWC->getTargetBufferQueue(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto renderEngine = std::make_unique(bufferQueue); + EXPECT_TRUE(renderEngine != nullptr); + + int imgWidth = 500; + int imgHeight = 500; + + // for 1st renderView -- begin -- + auto renderViewA = renderEngine->makeRenderView(); + EXPECT_TRUE(renderViewA != nullptr); + + // create RED image buffer + tbm_surface_h tbmTextureA = DSRenderEngineDaliTest::createTbmTexture( + imgWidth, imgHeight, 255, 0, 0, 255); + EXPECT_TRUE(tbmTextureA != nullptr); + + auto imageSourceBufferA = std::make_shared (imgWidth, imgHeight, IDSBuffer::FORMAT_ARGB8888, tbmTextureA); + EXPECT_TRUE(renderViewA->setBuffer(imageSourceBufferA)); + // -- end -- + + // for 2nd renderView -- begin -- + auto renderViewB = renderEngine->makeRenderView(); + EXPECT_TRUE(renderViewB != nullptr); + + // The buffer size of the second renderView is half of the first. + // create BLUE image buffer + tbm_surface_h tbmTextureB = DSRenderEngineDaliTest::createTbmTexture( + imgWidth/2, imgHeight/2, 0, 0, 255, 255); + EXPECT_TRUE(tbmTextureB != nullptr); + + auto imageSourceBufferB = std::make_shared (imgWidth/2, imgHeight/2, IDSBuffer::FORMAT_ARGB8888, tbmTextureB); + EXPECT_TRUE(renderViewB->setBuffer(imageSourceBufferB)); + // -- end -- + + // raise renderViewA to Top + renderViewB->lowerToBottom(); + + EXPECT_TRUE(renderEngine->renderFrame()); + + /* + * Since renderViewA was created and added before renderViewB, + * renderViewB should be drawn above and renderViewA below. + * But because renderViewB called lowerToBottom(), B lower down and covered by A. + * + * ┌─────────────┐ + * │ │ + * │ A │ + * │ │ + * │ red │ + * │ 　 │ + * └─────────────┘ + */ + + usleep(1000000); + + EXPECT_TRUE(bufferQueue->canAcquireBuffer(true)); + + // commit + EXPECT_TRUE(deviceHWC->commit()); + + usleep(1000000); + } +} + +TEST_F(DSRenderEngineDaliTest, RenderEngine_SetPosition) +{ + std::unique_ptr displayDevice = std::make_unique(); + std::list> outputList = displayDevice->getOutputList(); + EXPECT_TRUE(outputList.size() != 0); + + IDSDisplayDeviceOutput::ConnectorType connType; + IDSDisplayDeviceOutput::ConnectState connState; + std::shared_ptr deviceHWC; + + for (std::shared_ptr output : outputList) { + connType = output->getConnectType(); + EXPECT_TRUE(connType <= IDSDisplayDeviceOutput::TYPE_DSI); + connState = output->getConnectState(); + EXPECT_TRUE(connState <= IDSDisplayDeviceOutput::STATE_MODESET); + if (connState == IDSDisplayDeviceOutput::STATE_DISCONNECTED) + continue; + + auto bestMode = (output->getAvailableModes()).front(); + EXPECT_TRUE(output->setMode(bestMode) == true); + EXPECT_TRUE(output->getMode() == bestMode); + + deviceHWC = output->getHWC(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto bufferQueue = deviceHWC->getTargetBufferQueue(); + EXPECT_TRUE(deviceHWC != nullptr); + + auto renderEngine = std::make_unique(bufferQueue); + EXPECT_TRUE(renderEngine != nullptr); + auto renderView = renderEngine->makeRenderView(); + EXPECT_TRUE(renderView != nullptr); + + renderView->setPosition(200, 200); + + int imgWidth = 500; + int imgHeight = 500; + + tbm_surface_h tbmTexture = DSRenderEngineDaliTest::createTbmTexture( + imgWidth, imgHeight, 255, 0, 0, 255); + EXPECT_TRUE(tbmTexture != nullptr); + + auto imageSourceBuffer = std::make_shared (imgWidth, imgHeight, IDSBuffer::FORMAT_ARGB8888, tbmTexture); + EXPECT_TRUE(renderView->setBuffer(imageSourceBuffer)); + EXPECT_TRUE(renderEngine->renderFrame()); + + usleep(1000000); + + EXPECT_TRUE(bufferQueue->canAcquireBuffer(true)); + + // commit + EXPECT_TRUE(deviceHWC->commit()); + + usleep(1000000); + } +} -- 2.7.4 From eb3e74057e8afcde13a3f29631e86c72ad85b78c Mon Sep 17 00:00:00 2001 From: Duna Oh Date: Wed, 2 Sep 2020 15:56:35 +0900 Subject: [PATCH 15/16] DSTizenAppinfoMgr: add more test cases for better code coverage Change-Id: I5d54261a7a1a00e87ddd2b8998928b2659058bf2 --- src/DSTizenAppinfo/DSTizenAppinfo.cpp | 27 +++++++++++++---- src/DSTizenAppinfo/DSTizenAppinfo.h | 14 ++++++--- src/DSTizenAppinfo/DSTizenAppinfoMgr.cpp | 52 ++++++++++++++++---------------- tests/DSTizenAppinfo-test.cpp | 52 +++++++++++++++++++++++++++----- 4 files changed, 100 insertions(+), 45 deletions(-) diff --git a/src/DSTizenAppinfo/DSTizenAppinfo.cpp b/src/DSTizenAppinfo/DSTizenAppinfo.cpp index 905ea02..aed4335 100644 --- a/src/DSTizenAppinfo/DSTizenAppinfo.cpp +++ b/src/DSTizenAppinfo/DSTizenAppinfo.cpp @@ -34,6 +34,10 @@ DSTizenAppinfo::DSTizenAppinfo(std::string appid) __appId = appid; } +DSTizenAppinfo::~DSTizenAppinfo() +{ +} + void DSTizenAppinfo::setAppId(std::string appId) { __appId = appId; @@ -44,31 +48,42 @@ void DSTizenAppinfo::setPid(pid_t pid) __pid = pid; } -DSTizenAppinfo::~DSTizenAppinfo() +void DSTizenAppinfo::setBaseOutputAvailable(bool isAvailable) +{ + __base_output_available = isAvailable; +} + +void DSTizenAppinfo::setBaseOutputWidth(int w) +{ + __base_output_width = w; +} + +void DSTizenAppinfo::setBaseOutputHeight(int h) { + __base_output_height = h; } -pid_t DSTizenAppinfo::pid() +pid_t DSTizenAppinfo::getPid() { return __pid; } -std::string DSTizenAppinfo::appId() +std::string DSTizenAppinfo::getAppId() { return __appId; } -bool DSTizenAppinfo::base_output_available() +bool DSTizenAppinfo::getBaseOutputAvailable() { return __base_output_available; } -int DSTizenAppinfo::base_output_width() +int DSTizenAppinfo::getBaseOutputWidth() { return __base_output_width; } -int DSTizenAppinfo::base_output_height() +int DSTizenAppinfo::getBaseOutputHeight() { return __base_output_height; } diff --git a/src/DSTizenAppinfo/DSTizenAppinfo.h b/src/DSTizenAppinfo/DSTizenAppinfo.h index 5eecb93..0564806 100644 --- a/src/DSTizenAppinfo/DSTizenAppinfo.h +++ b/src/DSTizenAppinfo/DSTizenAppinfo.h @@ -38,11 +38,15 @@ public: void setAppId(std::string appId); void setPid(pid_t pid); - pid_t pid(void); - std::string appId(void); - bool base_output_available(void); - int base_output_width(void); - int base_output_height(void); + void setBaseOutputAvailable(bool isAvailable); + void setBaseOutputWidth(int w); + void setBaseOutputHeight(int h); + + std::string getAppId(void); + pid_t getPid(void); + bool getBaseOutputAvailable(void); + int getBaseOutputWidth(void); + int getBaseOutputHeight(void); private: std::string __appId; diff --git a/src/DSTizenAppinfo/DSTizenAppinfoMgr.cpp b/src/DSTizenAppinfo/DSTizenAppinfoMgr.cpp index 356e865..e63dc22 100644 --- a/src/DSTizenAppinfo/DSTizenAppinfoMgr.cpp +++ b/src/DSTizenAppinfo/DSTizenAppinfoMgr.cpp @@ -54,17 +54,17 @@ std::shared_ptr DSTizenAppinfoMgrPrivate::getTizenAppinfo(std::s std::shared_ptr DSTizenAppinfoMgrPrivate::getTizenAppinfo(pid_t pid) { - std::shared_ptr ptr_appinfo; - DSTizenAppinfo * appinfo; + std::shared_ptr ptr_appinfo(nullptr); + DSTizenAppinfo * appinfo(nullptr); for (auto it = __appIdMap.begin(); it != __appIdMap.end(); it++) { ptr_appinfo = it->second; - if (ptr_appinfo == nullptr) - continue; - - appinfo = ptr_appinfo.get() ; - if ((appinfo) && (appinfo->pid() == pid)) { - return ptr_appinfo; + if (ptr_appinfo) + { + appinfo = ptr_appinfo.get() ; + if ((appinfo) && (appinfo->getPid() == pid)) { + return ptr_appinfo; + } } } return nullptr; @@ -72,7 +72,7 @@ std::shared_ptr DSTizenAppinfoMgrPrivate::getTizenAppinfo(pid_t std::shared_ptr DSTizenAppinfoMgrPrivate::addTizenAppinfo(std::string appId) { - std::shared_ptr appinfo = nullptr; + std::shared_ptr appinfo(nullptr); appinfo = std::make_shared(appId); if (appinfo != nullptr) { @@ -154,10 +154,12 @@ std::shared_ptr DSTizenAppinfoMgr::addTizenAppinfo(std::string a if (appinfo == nullptr) { appinfo = priv->addTizenAppinfo(appId); DSLOG_INF("DSTizenAppinfoMgr", "New TizenAppinfo(apppId:%s) added", appId.c_str()); + return appinfo; } - else + else { DSLOG_INF("DSTizenAppinfoMgr", "Adding TizenAppinfo(apppId:%s) failed..", appId.c_str()); - return appinfo; + return nullptr; + } } bool DSTizenAppinfoMgr::removeTizenAppinfo(std::string appId) @@ -167,16 +169,16 @@ bool DSTizenAppinfoMgr::removeTizenAppinfo(std::string appId) ret = priv->removeTizenAppinfo(appId); if (ret) - DSLOG_INF("DSTizenAppinfoMgr", "Removing TizenAppinfo(appId:%s) failedd..", appId.c_str()); - else DSLOG_INF("DSTizenAppinfoMgr", "TizenAppinfo(appId:%s) removed", appId.c_str()); + else + DSLOG_INF("DSTizenAppinfoMgr", "Removing TizenAppinfo(appId:%s) failed..", appId.c_str()); return ret; } void DSTizenAppinfoMgr::updateTizenAppinfo(std::string appId, pid_t pid) { - std::shared_ptr ptr_appinfo; - DSTizenAppinfo * appinfo; + std::shared_ptr ptr_appinfo(nullptr); + DSTizenAppinfo * appinfo(nullptr); ptr_appinfo = getTizenAppinfo(appId); if (ptr_appinfo == nullptr) @@ -192,23 +194,21 @@ void DSTizenAppinfoMgr::updateTizenAppinfo(std::string appId, pid_t pid) bool DSTizenAppinfoMgr::getBaseOutputResolution(pid_t pid, int *res_w, int *res_h) { - std::shared_ptr ptr_appinfo; - DSTizenAppinfo * appinfo; + std::shared_ptr ptr_appinfo(nullptr); + DSTizenAppinfo * appinfo(nullptr); ptr_appinfo = getTizenAppinfo(pid); - if (ptr_appinfo = nullptr) + if (ptr_appinfo == nullptr) return false; appinfo = ptr_appinfo.get(); - if (appinfo == nullptr) - return false; - - if (!appinfo->base_output_available()) - return false; + if ((appinfo) && (appinfo->getBaseOutputAvailable())) { + if (res_w) *res_w = appinfo->getBaseOutputWidth(); + if (res_h) *res_h = appinfo->getBaseOutputHeight(); - if (res_w) *res_w = appinfo->base_output_width(); - if (res_h) *res_h = appinfo->base_output_height(); - return true; + return true; + } + return false; } } diff --git a/tests/DSTizenAppinfo-test.cpp b/tests/DSTizenAppinfo-test.cpp index 2b2b7bc..10a0d8a 100644 --- a/tests/DSTizenAppinfo-test.cpp +++ b/tests/DSTizenAppinfo-test.cpp @@ -44,9 +44,20 @@ public: TEST_F(DSTizenAppinfoTest, NewTizenAppinfo) { std::string appId1{"com.appinfo.first"}; + std::string appId2{"com.appinfo.second"}; + DSTizenAppinfo *appinfo = new DSTizenAppinfo(appId1); EXPECT_TRUE(appinfo != nullptr); + pid_t pid = 1234; + appinfo->setPid(pid); + appinfo->setAppId(appId2); + EXPECT_TRUE(appinfo->getAppId().compare(appId2) == 0); + + EXPECT_TRUE(appinfo->getBaseOutputAvailable() == false); + EXPECT_TRUE(appinfo->getBaseOutputWidth() == 0); + EXPECT_TRUE(appinfo->getBaseOutputHeight() == 0); + if (appinfo) delete appinfo; } @@ -60,20 +71,45 @@ TEST_F(DSTizenAppinfoTest, NewTizenAppinfoMgr) { std::string appId1{"com.appinfo.first"}; std::string appId2{"com.appinfo.second"}; + std::string appId3{"com.appinfo.third"}; + pid_t pid1 = 1234, pid2 = 4321; + int res_w = 0, res_h = 0; - std::shared_ptr app1 = appinfoMgr->addTizenAppinfo(appId1); + std::shared_ptr app1(nullptr), app2(nullptr), app3(nullptr), temp(nullptr); + + app1 = appinfoMgr->addTizenAppinfo(appId1); EXPECT_TRUE(app1 != nullptr); - std::shared_ptr app2 = appinfoMgr->addTizenAppinfo(appId2); + app2 = appinfoMgr->addTizenAppinfo(appId2); EXPECT_TRUE(app2 != nullptr); + //FAIL to add a new appinfo using the existing appId + app3 = appinfoMgr->addTizenAppinfo(appId2); + EXPECT_TRUE(app3 == nullptr); + + temp = appinfoMgr->getTizenAppinfo(appId2); + EXPECT_TRUE(temp != nullptr); + + EXPECT_TRUE(appinfoMgr->removeTizenAppinfo(appId2) == true); + //FAIL to remove non-existing appinfo + EXPECT_TRUE(appinfoMgr->removeTizenAppinfo("com.appinfo.noname") == false); - std::shared_ptr temp = appinfoMgr->getTizenAppinfo(appId2); + app1->setPid(pid1); //app1 - (appId1, 1234) + temp = nullptr; + temp = appinfoMgr->getTizenAppinfo(pid1); //temp = app1 - (appId1, 1234) EXPECT_TRUE(temp != nullptr); - appinfoMgr->removeTizenAppinfo(appId2); - pid_t pid = 1234; - app1->setPid(pid); - temp = appinfoMgr->getTizenAppinfo(pid); - appinfoMgr->removeTizenAppinfo(temp->appId()); + appinfoMgr->updateTizenAppinfo(appId1, pid2); //app1 - (appId1, 4321) + appinfoMgr->updateTizenAppinfo(appId2, pid2); //no appinfo with appId2 + + EXPECT_TRUE(appinfoMgr->getBaseOutputResolution(pid1, &res_w, &res_h) == false); //no appinfo with pid1 + + app1->setBaseOutputAvailable(true); + app1->setBaseOutputWidth(720); + app1->setBaseOutputHeight(1280); + + EXPECT_TRUE(appinfoMgr->getBaseOutputResolution(pid2, &res_w, &res_h) == true); //app1 + EXPECT_TRUE(res_w == 720); + EXPECT_TRUE(res_h == 1280); + appinfoMgr->removeTizenAppinfo(app1->getAppId()); DSTizenAppinfoMgr::releaseInstance(); } -- 2.7.4 From 1e7e3fbe1de7c8f5b394d6f956ed209c06255125 Mon Sep 17 00:00:00 2001 From: Doyoun Kang Date: Wed, 2 Sep 2020 16:38:49 +0900 Subject: [PATCH 16/16] DSWindow: add set/getType APIs Change-Id: Ic199b31bd3df174bc818788cc4d3b6b79169f9be --- src/DSWindow/DSWindow.cpp | 26 +++++++++++++++++++++++++- src/DSWindow/DSWindow.h | 3 +++ src/DSWindow/DSWindowPrivate.h | 4 ++++ 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/src/DSWindow/DSWindow.cpp b/src/DSWindow/DSWindow.cpp index eeecad6..300e29d 100644 --- a/src/DSWindow/DSWindow.cpp +++ b/src/DSWindow/DSWindow.cpp @@ -33,6 +33,7 @@ DSWindowPrivate::DSWindowPrivate(DSWindow *p_ptr) : DSObjectPrivate(p_ptr), __p_ptr(p_ptr), __parent(nullptr), + __type(0), __x(0), __y(0), __w(0), @@ -70,6 +71,16 @@ void DSWindowPrivate::destroy(void) { } +void DSWindowPrivate::setType(int type) +{ + __type = type; +} + +int DSWindowPrivate::getType(void) +{ + return __type; +} + void DSWindowPrivate::setParent(DSWindow *parent) { __parent = parent; @@ -279,6 +290,19 @@ void DSWindow::destroy(void) priv->destroy(); } +void DSWindow::setType(int type) +{ + DSLOG_DBG("DSWindow", "Set type (%d). DSWindow:%p", type, this); + DS_GET_PRIV(DSWindow); + priv->setType(type); +} + +int DSWindow::getType(void) +{ + DS_GET_PRIV(DSWindow); + return priv->getType(); +} + void DSWindow::setParent(DSWindow *parent) { if (parent == this) return; @@ -316,7 +340,7 @@ int DSWindow::showState(void) bool DSWindow::setTitle(const std::string &title) { - DSLOG_DBG("DSWindow", "title:%s", title.c_str()); + DSLOG_DBG("DSWindow", "title:%s. DSWindow:%p", title.c_str(), this); DS_GET_PRIV(DSWindow); return priv->setTitle(title); diff --git a/src/DSWindow/DSWindow.h b/src/DSWindow/DSWindow.h index 808cc03..ac303b7 100644 --- a/src/DSWindow/DSWindow.h +++ b/src/DSWindow/DSWindow.h @@ -50,6 +50,9 @@ public: bool create(std::shared_ptr waylandSurface); void destroy(void); + void setType(int type); + int getType(void); + void setParent(DSWindow *parent); DSWindow *getParent(void); diff --git a/src/DSWindow/DSWindowPrivate.h b/src/DSWindow/DSWindowPrivate.h index b7e35d5..eb71181 100644 --- a/src/DSWindow/DSWindowPrivate.h +++ b/src/DSWindow/DSWindowPrivate.h @@ -47,6 +47,9 @@ public: bool create(std::shared_ptr waylandSurface); void destroy(void); + void setType(int type); + int getType(void); + void setParent(DSWindow *parent); DSWindow *getParent(void); @@ -86,6 +89,7 @@ private: DSWindow *__parent; std::list __childList; + int __type; int __x, __y; unsigned int __w; unsigned int __h; -- 2.7.4