Unify unit tests cleanup

[Bug/Feature]   N/A
[Cause]         N/A
[Solution]      N/A
[Verification]  Run tests

Change-Id: I2a49450b3991355656028194b14f9eae5a222456

diff --git a/tests/unit_tests/dbus/configs/ut-connection/ut-dbus.conf b/tests/unit_tests/dbus/configs/ut-connection/ut-dbus.conf
index f3bf58c..d6091a2 100644 (file)
--- a/tests/unit_tests/dbus/configs/ut-connection/ut-dbus.conf
+++ b/tests/unit_tests/dbus/configs/ut-connection/ut-dbus.conf
@@ -5,7 +5,7 @@
 
 <busconfig>
     <type>custom</type>
-    <listen>unix:path=/tmp/zone_socket</listen>
+    <listen>unix:path=/tmp/ut-dbus/test-socket</listen>
 
     <policy context="default">
         <!-- Allow everything to be sent -->

diff --git a/tests/unit_tests/dbus/test-common.hpp b/tests/unit_tests/dbus/test-common.hpp
index ae76d82..7b6262b 100644 (file)
--- a/tests/unit_tests/dbus/test-common.hpp
+++ b/tests/unit_tests/dbus/test-common.hpp
@@ -31,8 +31,9 @@
 namespace vasum {
 
 
-const std::string DBUS_SOCKET_FILE       = "/tmp/zone_socket";
-const std::string DBUS_ADDRESS           = "unix:path=" + DBUS_SOCKET_FILE;
+const std::string DBUS_SOCKET_DIR        = "/tmp/ut-dbus";
+const std::string DBUS_SOCKET_PATH       = DBUS_SOCKET_DIR + "/test-socket";
+const std::string DBUS_ADDRESS           = "unix:path=" + DBUS_SOCKET_PATH;
 
 const std::string TESTAPI_BUS_NAME       = "org.tizen.tests";
 const std::string TESTAPI_OBJECT_PATH    = "/org/tizen/tests";

diff --git a/tests/unit_tests/dbus/ut-connection.cpp b/tests/unit_tests/dbus/ut-connection.cpp
index 5182225..4948cd7 100644 (file)
--- a/tests/unit_tests/dbus/ut-connection.cpp
+++ b/tests/unit_tests/dbus/ut-connection.cpp
@@ -28,6 +28,7 @@
 #include "dbus/test-client.hpp"
 #include "dbus/test-common.hpp"
 #include "utils/scoped-daemon.hpp"
+#include "utils/scoped-dir.hpp"
 
 #include "dbus/connection.hpp"
 #include "dbus/exception.hpp"
@@ -37,7 +38,6 @@
 #include "utils/fs.hpp"
 #include "logger/logger.hpp"
 
-#include <boost/filesystem.hpp>
 #include <thread>
 #include <mutex>
 #include <condition_variable>
@@ -65,16 +65,17 @@ const int EVENT_TIMEOUT = 1000;
 class ScopedDbusDaemon {
 public:
     ScopedDbusDaemon()
+        : mTestPathGuard(DBUS_SOCKET_DIR)
     {
-        boost::filesystem::remove("/tmp/zone_socket");
         mDaemon.start(DBUS_DAEMON_PROC, DBUS_DAEMON_ARGS);
-        waitForFile(DBUS_SOCKET_FILE, DBUS_DAEMON_TIMEOUT);
+        waitForFile(DBUS_SOCKET_PATH, DBUS_DAEMON_TIMEOUT);
     }
     void stop()
     {
         mDaemon.stop();
     }
 private:
+    ScopedDir mTestPathGuard;
     ScopedDaemon mDaemon;
 };
 

diff --git a/tests/unit_tests/ipc/ut-ipc.cpp b/tests/unit_tests/ipc/ut-ipc.cpp
index 56c94cb..193eec9 100644 (file)
--- a/tests/unit_tests/ipc/ut-ipc.cpp
+++ b/tests/unit_tests/ipc/ut-ipc.cpp
@@ -37,6 +37,7 @@
 #include "utils/glib-loop.hpp"
 #include "utils/latch.hpp"
 #include "utils/value-latch.hpp"
+#include "utils/scoped-dir.hpp"
 
 #include "config/fields.hpp"
 #include "logger/logger.hpp"
@@ -47,13 +48,11 @@
 #include <chrono>
 #include <utility>
 #include <future>
-#include <boost/filesystem.hpp>
 
 using namespace vasum;
 using namespace vasum::ipc;
 using namespace vasum::utils;
 using namespace std::placeholders;
-namespace fs = boost::filesystem;
 
 namespace {
 
@@ -66,16 +65,16 @@ const int SHORT_OPERATION_TIME = TIMEOUT / 100;
 // Time that will cause "TIMEOUT" methods to throw
 const int LONG_OPERATION_TIME = 1000 + TIMEOUT;
 
+const std::string TEST_DIR = "/tmp/ut-ipc";
+const std::string SOCKET_PATH = TEST_DIR + "/test.socket";
+
 struct Fixture {
-    std::string socketPath;
+    ScopedDir mTestPathGuard;
+    std::string SOCKET_PATH;
 
     Fixture()
-        : socketPath(fs::unique_path("/tmp/ipc-%%%%.socket").string())
-    {
-    }
-    ~Fixture()
+        : mTestPathGuard(TEST_DIR)
     {
-        fs::remove(socketPath);
     }
 };
 
@@ -224,13 +223,13 @@ BOOST_FIXTURE_TEST_SUITE(IPCSuite, Fixture)
 
 BOOST_AUTO_TEST_CASE(ConstructorDestructor)
 {
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
 }
 
 BOOST_AUTO_TEST_CASE(ServiceAddRemoveMethod)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<EmptyData, EmptyData>(1, returnEmptyCallback);
     s.setMethodHandler<SendData, RecvData>(1, returnDataCallback);
 
@@ -239,7 +238,7 @@ BOOST_AUTO_TEST_CASE(ServiceAddRemoveMethod)
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.setMethodHandler<SendData, RecvData>(2, returnDataCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     connect(s, c);
     testEcho(c, 1);
 
@@ -251,8 +250,8 @@ BOOST_AUTO_TEST_CASE(ServiceAddRemoveMethod)
 
 BOOST_AUTO_TEST_CASE(ClientAddRemoveMethod)
 {
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     c.setMethodHandler<EmptyData, EmptyData>(1, returnEmptyCallback);
     c.setMethodHandler<SendData, RecvData>(1, returnDataCallback);
 
@@ -271,7 +270,7 @@ BOOST_AUTO_TEST_CASE(ClientAddRemoveMethod)
 
 BOOST_AUTO_TEST_CASE(ServiceStartStop)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
 
     s.setMethodHandler<SendData, RecvData>(1, returnDataCallback);
 
@@ -286,8 +285,8 @@ BOOST_AUTO_TEST_CASE(ServiceStartStop)
 
 BOOST_AUTO_TEST_CASE(ClientStartStop)
 {
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     c.setMethodHandler<SendData, RecvData>(1, returnDataCallback);
 
     c.start();
@@ -304,11 +303,11 @@ BOOST_AUTO_TEST_CASE(ClientStartStop)
 
 BOOST_AUTO_TEST_CASE(SyncClientToServiceEcho)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.setMethodHandler<SendData, RecvData>(2, echoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     connect(s, c);
 
     testEcho(c, 1);
@@ -317,12 +316,12 @@ BOOST_AUTO_TEST_CASE(SyncClientToServiceEcho)
 
 BOOST_AUTO_TEST_CASE(Restart)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.start();
     s.setMethodHandler<SendData, RecvData>(2, echoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.start();
     testEcho(c, 1);
     testEcho(c, 2);
@@ -342,8 +341,8 @@ BOOST_AUTO_TEST_CASE(Restart)
 
 BOOST_AUTO_TEST_CASE(SyncServiceToClientEcho)
 {
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     c.setMethodHandler<SendData, RecvData>(1, echoCallback);
     PeerID peerID = connect(s, c);
 
@@ -359,10 +358,10 @@ BOOST_AUTO_TEST_CASE(AsyncClientToServiceEcho)
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatch;
 
     // Setup Service and Client
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.start();
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.start();
 
     //Async call
@@ -381,8 +380,8 @@ BOOST_AUTO_TEST_CASE(AsyncServiceToClientEcho)
     std::shared_ptr<SendData> sentData(new SendData(56));
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatch;
 
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     c.setMethodHandler<SendData, RecvData>(1, echoCallback);
     PeerID peerID = connect(s, c);
 
@@ -401,10 +400,10 @@ BOOST_AUTO_TEST_CASE(AsyncServiceToClientEcho)
 
 BOOST_AUTO_TEST_CASE(SyncTimeout)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, longEchoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     connect(s, c);
 
     std::shared_ptr<SendData> sentData(new SendData(78));
@@ -413,10 +412,10 @@ BOOST_AUTO_TEST_CASE(SyncTimeout)
 
 BOOST_AUTO_TEST_CASE(SerializationError)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     connect(s, c);
 
     std::shared_ptr<ThrowOnAcceptData> throwingData(new ThrowOnAcceptData());
@@ -427,11 +426,11 @@ BOOST_AUTO_TEST_CASE(SerializationError)
 
 BOOST_AUTO_TEST_CASE(ParseError)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.start();
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.start();
 
     std::shared_ptr<SendData> sentData(new SendData(78));
@@ -441,7 +440,7 @@ BOOST_AUTO_TEST_CASE(ParseError)
 BOOST_AUTO_TEST_CASE(DisconnectedPeerError)
 {
     ValueLatch<Result<RecvData>> retStatusLatch;
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
 
     auto method = [](const PeerID, std::shared_ptr<ThrowOnAcceptData>&, MethodResult::Pointer methodResult) {
         auto resultData = std::make_shared<SendData>(1);
@@ -452,7 +451,7 @@ BOOST_AUTO_TEST_CASE(DisconnectedPeerError)
     s.setMethodHandler<SendData, ThrowOnAcceptData>(1, method);
     s.start();
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.start();
 
     auto dataBack = [&retStatusLatch](Result<RecvData> && r) {
@@ -474,14 +473,14 @@ BOOST_AUTO_TEST_CASE(DisconnectedPeerError)
 
 BOOST_AUTO_TEST_CASE(ReadTimeout)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     auto longEchoCallback = [](const PeerID, std::shared_ptr<RecvData>& data, MethodResult::Pointer methodResult) {
         auto resultData = std::make_shared<LongSendData>(data->intVal, LONG_OPERATION_TIME);
         methodResult->set<LongSendData>(resultData);
     };
     s.setMethodHandler<LongSendData, RecvData>(1, longEchoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     connect(s, c);
 
     // Test timeout on read
@@ -492,11 +491,11 @@ BOOST_AUTO_TEST_CASE(ReadTimeout)
 
 BOOST_AUTO_TEST_CASE(WriteTimeout)
 {
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
     s.start();
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.start();
 
     // Test echo with a minimal timeout
@@ -516,8 +515,8 @@ BOOST_AUTO_TEST_CASE(AddSignalInRuntime)
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatchA;
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatchB;
 
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     connect(s, c);
 
     auto handlerA = [&recvDataLatchA](const PeerID, std::shared_ptr<RecvData>& data) {
@@ -552,8 +551,8 @@ BOOST_AUTO_TEST_CASE(AddSignalOffline)
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatchA;
     ValueLatch<std::shared_ptr<RecvData>> recvDataLatchB;
 
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
 
     auto handlerA = [&recvDataLatchA](const PeerID, std::shared_ptr<RecvData>& data) {
         recvDataLatchA.set(data);
@@ -594,10 +593,10 @@ BOOST_AUTO_TEST_CASE(ServiceGSource)
     };
 
     IPCGSource::Pointer serviceGSource;
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
 
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     s.setSignalHandler<RecvData>(2, signalHandler);
 
     connectServiceGSource(s, c);
@@ -620,11 +619,11 @@ BOOST_AUTO_TEST_CASE(ClientGSource)
         l.set();
     };
 
-    Service s(socketPath);
+    Service s(SOCKET_PATH);
     s.start();
 
     IPCGSource::Pointer clientGSource;
-    Client c(socketPath);
+    Client c(SOCKET_PATH);
     c.setMethodHandler<SendData, RecvData>(1, echoCallback);
     c.setSignalHandler<RecvData>(2, signalHandler);
 
@@ -643,8 +642,8 @@ BOOST_AUTO_TEST_CASE(UsersError)
     const int TEST_ERROR_CODE = -234;
     const std::string TEST_ERROR_MESSAGE = "Ay, caramba!";
 
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     auto clientID = connect(s, c);
 
     auto throwingMethodHandler = [&](const PeerID, std::shared_ptr<RecvData>&, MethodResult::Pointer) {
@@ -677,8 +676,8 @@ BOOST_AUTO_TEST_CASE(AsyncResult)
     const int TEST_ERROR_CODE = -567;
     const std::string TEST_ERROR_MESSAGE = "Ooo jooo!";
 
-    Service s(socketPath);
-    Client c(socketPath);
+    Service s(SOCKET_PATH);
+    Client c(SOCKET_PATH);
     auto clientID = connect(s, c);
 
     auto errorMethodHandler = [&](const PeerID, std::shared_ptr<RecvData>&, MethodResult::Pointer methodResult) {
@@ -734,14 +733,14 @@ BOOST_AUTO_TEST_CASE(AsyncResult)
 //     ipc::setMaxFDNumber(50);
 
 //     // Setup Service and many Clients
-//     Service s(socketPath);
+//     Service s(SOCKET_PATH);
 //     s.setMethodHandler<SendData, RecvData>(1, echoCallback);
 //     s.start();
 
 //     std::list<Client> clients;
 //     for (int i = 0; i < 100; ++i) {
 //         try {
-//             clients.push_back(Client(socketPath));
+//             clients.push_back(Client(SOCKET_PATH));
 //             clients.back().start();
 //         } catch (...) {}
 //     }

diff --git a/tests/unit_tests/server/configs/ut-zone-connection/ut-dbus.conf b/tests/unit_tests/server/configs/ut-zone-connection/ut-dbus.conf
index d60e774..66ee3f9 100644 (file)
--- a/tests/unit_tests/server/configs/ut-zone-connection/ut-dbus.conf
+++ b/tests/unit_tests/server/configs/ut-zone-connection/ut-dbus.conf
@@ -5,7 +5,7 @@
 
 <busconfig>
     <type>custom</type>
-    <listen>unix:path=/tmp/ut-zone-connection/dbus/system_bus_socket</listen>
+    <listen>unix:path=/tmp/ut-zones/mount-point/dbus/system_bus_socket</listen>
 
     <policy context="default">
         <!-- Allow everything to be sent -->

diff --git a/tests/unit_tests/server/ut-input-monitor.cpp b/tests/unit_tests/server/ut-input-monitor.cpp
index 9b4292f..3560b40 100644 (file)
--- a/tests/unit_tests/server/ut-input-monitor.cpp
+++ b/tests/unit_tests/server/ut-input-monitor.cpp
@@ -32,6 +32,7 @@
 
 #include "utils/glib-loop.hpp"
 #include "utils/latch.hpp"
+#include "utils/scoped-dir.hpp"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -39,7 +40,6 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include <boost/filesystem.hpp>
 #include <chrono>
 #include <memory>
 #include <string>
@@ -50,8 +50,8 @@ using namespace vasum::utils;
 
 namespace {
 
-std::string TEST_INPUT_DEVICE =
-    boost::filesystem::unique_path("/tmp/testInputDevice-%%%%").string();
+const std::string TEST_DIR = "/tmp/ut-input-monitor";
+const std::string TEST_INPUT_DEVICE = TEST_DIR + "/input-device";
 
 const int EVENT_TYPE = 1;
 const int EVENT_CODE = 139;
@@ -61,11 +61,13 @@ const int EVENT_BUTTON_PRESSED = 1;
 const int SINGLE_EVENT_TIMEOUT = 1000;
 
 struct Fixture {
-    InputConfig inputConfig;
     utils::ScopedGlibLoop mLoop;
+    ScopedDir mTestPathGuard;
+    InputConfig inputConfig;
     struct input_event ie;
 
     Fixture()
+        : mTestPathGuard(TEST_DIR)
     {
         inputConfig.numberOfEvents = 2;
         inputConfig.device = TEST_INPUT_DEVICE;
@@ -80,13 +82,8 @@ struct Fixture {
         ie.code = EVENT_CODE;
         ie.value = EVENT_BUTTON_RELEASED;
 
-        ::remove(TEST_INPUT_DEVICE.c_str());
         BOOST_CHECK(::mkfifo(TEST_INPUT_DEVICE.c_str(), S_IWUSR | S_IRUSR) >= 0);
     }
-    ~Fixture()
-    {
-        ::remove(TEST_INPUT_DEVICE.c_str());
-    }
 };
 } // namespace
 

diff --git a/tests/unit_tests/server/ut-zone-connection.cpp b/tests/unit_tests/server/ut-zone-connection.cpp
index 6d3e8e4..fb6df88 100644 (file)
--- a/tests/unit_tests/server/ut-zone-connection.cpp
+++ b/tests/unit_tests/server/ut-zone-connection.cpp
@@ -39,10 +39,9 @@
 #include "utils/glib-loop.hpp"
 #include "utils/latch.hpp"
 #include "utils/fs.hpp"
+#include "utils/scoped-dir.hpp"
 
 
-BOOST_AUTO_TEST_SUITE(ZoneConnectionSuite)
-
 using namespace vasum;
 using namespace vasum::utils;
 using namespace dbus;
@@ -57,13 +56,15 @@ const char* const DBUS_DAEMON_ARGS[] = {
     NULL
 };
 
-const std::string TRANSPORT_MOUNT_POINT = "/tmp/ut-zone-connection";
+const std::string ZONES_PATH = "/tmp/ut-zones";
+const std::string TRANSPORT_MOUNT_POINT = ZONES_PATH + "/mount-point";
 const int EVENT_TIMEOUT = 1000;
 
-class ScopedDbusDaemon {
+class Fixture {
 public:
-    ScopedDbusDaemon()
-        : mTransport(TRANSPORT_MOUNT_POINT)
+    Fixture()
+        : mZonesPathGuard(ZONES_PATH)
+        , mTransport(TRANSPORT_MOUNT_POINT)
     {
         mDaemon.start(DBUS_DAEMON_PROC, DBUS_DAEMON_ARGS);
     }
@@ -73,6 +74,8 @@ public:
         return mTransport.acquireAddress();
     }
 private:
+    ScopedGlibLoop mLoop;
+    ScopedDir mZonesPathGuard;
     ZoneConnectionTransport mTransport;
     ScopedDaemon mDaemon;
 };
@@ -126,22 +129,17 @@ private:
 
 } // namespace
 
+BOOST_FIXTURE_TEST_SUITE(ZoneConnectionSuite, Fixture)
 
 BOOST_AUTO_TEST_CASE(ConstructorDestructorConnectTest)
 {
-    ScopedGlibLoop loop;
-    ScopedDbusDaemon dbus;
-
-    ZoneConnection(dbus.acquireAddress(), nullptr);
+    ZoneConnection(acquireAddress(), nullptr);
 }
 
 BOOST_AUTO_TEST_CASE(NotifyActiveZoneApiTest)
 {
-    ScopedGlibLoop loop;
-    ScopedDbusDaemon dbus;
-
     Latch notifyCalled;
-    ZoneConnection connection(dbus.acquireAddress(), nullptr);
+    ZoneConnection connection(acquireAddress(), nullptr);
 
     auto callback = [&](const std::string& application, const std::string& message) {
         if (application == "testapp" && message == "testmessage") {
@@ -150,7 +148,7 @@ BOOST_AUTO_TEST_CASE(NotifyActiveZoneApiTest)
     };
     connection.setNotifyActiveZoneCallback(callback);
 
-    DbusConnection::Pointer client = DbusConnection::create(dbus.acquireAddress());
+    DbusConnection::Pointer client = DbusConnection::create(acquireAddress());
     client->callMethod(api::zone::BUS_NAME,
                        api::zone::OBJECT_PATH,
                        api::zone::INTERFACE,
@@ -162,13 +160,10 @@ BOOST_AUTO_TEST_CASE(NotifyActiveZoneApiTest)
 
 BOOST_AUTO_TEST_CASE(SignalNotificationApiTest)
 {
-    ScopedGlibLoop loop;
-    ScopedDbusDaemon dbus;
-
     Latch signalEmitted;
-    ZoneConnection connection(dbus.acquireAddress(), nullptr);
+    ZoneConnection connection(acquireAddress(), nullptr);
 
-    DbusConnection::Pointer client = DbusConnection::create(dbus.acquireAddress());
+    DbusConnection::Pointer client = DbusConnection::create(acquireAddress());
 
     auto handler = [&](const std::string& /*senderBusName*/,
                        const std::string& objectPath,
@@ -200,13 +195,10 @@ BOOST_AUTO_TEST_CASE(SignalNotificationApiTest)
 
 BOOST_AUTO_TEST_CASE(SignalDisplayOffApiTest)
 {
-    ScopedGlibLoop loop;
-    ScopedDbusDaemon dbus;
-
     Latch displayOffCalled;
-    ZoneConnection connection(dbus.acquireAddress(), nullptr);
+    ZoneConnection connection(acquireAddress(), nullptr);
 
-    DbusConnection::Pointer client = DbusConnection::create(dbus.acquireAddress());
+    DbusConnection::Pointer client = DbusConnection::create(acquireAddress());
 
     auto callback = [&]() {
         displayOffCalled.set();

diff --git a/tests/unit_tests/utils/ut-fs.cpp b/tests/unit_tests/utils/ut-fs.cpp
index 365c1e1..b2defba 100644 (file)
--- a/tests/unit_tests/utils/ut-fs.cpp
+++ b/tests/unit_tests/utils/ut-fs.cpp
@@ -28,54 +28,53 @@
 
 #include "utils/fs.hpp"
 #include "utils/exception.hpp"
+#include "utils/scoped-dir.hpp"
 
 #include <memory>
 #include <sys/mount.h>
 #include <boost/filesystem.hpp>
 
-BOOST_AUTO_TEST_SUITE(UtilsFSSuite)
-
 using namespace vasum;
 using namespace vasum::utils;
 
 namespace {
 
-const std::string FILE_PATH = VSM_TEST_CONFIG_INSTALL_DIR "/utils/ut-fs/file.txt";
-const std::string FILE_CONTENT = "File content\n"
-                                 "Line 1\n"
-                                 "Line 2\n";
+const std::string TEST_PATH = "/tmp/ut-fsutils";
+const std::string REFERENCE_FILE_PATH = VSM_TEST_CONFIG_INSTALL_DIR "/utils/ut-fs/file.txt";
+const std::string REFERENCE_FILE_CONTENT = "File content\n"
+                                           "Line 1\n"
+                                           "Line 2\n";
 const std::string FILE_CONTENT_2 = "Some other content\n"
                                    "Just to see if\n"
                                    "everything is copied correctly\n";
 const std::string FILE_CONTENT_3 = "More content\n"
                                    "More and more content\n"
                                    "That's a lot of data to test\n";
-const std::string BUGGY_FILE_PATH = "/some/missing/file/path/file.txt";
-const std::string TMP_PATH = "/tmp";
-const std::string FILE_PATH_RANDOM =
-    boost::filesystem::unique_path("/tmp/testFile-%%%%").string();
-const std::string MOUNT_POINT_RANDOM_1 =
-    boost::filesystem::unique_path("/tmp/mountPoint-%%%%").string();
-const std::string MOUNT_POINT_RANDOM_2 =
-    boost::filesystem::unique_path("/tmp/mountPoint-%%%%").string();
-const std::string FILE_DIR_RANDOM_1 =
-    boost::filesystem::unique_path("testDir-%%%%").string();
-const std::string FILE_DIR_RANDOM_2 =
-    boost::filesystem::unique_path("testDir-%%%%").string();
-const std::string FILE_DIR_RANDOM_3 =
-    boost::filesystem::unique_path("testDir-%%%%").string();
-const std::string FILE_DIR_RANDOM_4 =
-    boost::filesystem::unique_path("testDir-%%%%").string();
-const std::string FILE_NAME_RANDOM_1 =
-    boost::filesystem::unique_path("testFile-%%%%").string();
-const std::string FILE_NAME_RANDOM_2 =
-    boost::filesystem::unique_path("testFile-%%%%").string();
+const std::string BUGGY_FILE_PATH = TEST_PATH + "/missing/file.txt";
+const std::string FILE_PATH = TEST_PATH + "/testFile";
+const std::string MOUNT_POINT_1 = TEST_PATH + "/mountPoint-1";
+const std::string MOUNT_POINT_2 = TEST_PATH + "/mountPoint-2";
+const std::string FILE_DIR_1 = "testDir-1";
+const std::string FILE_DIR_2 = "testDir-2";
+const std::string FILE_DIR_3 = "testDir-3";
+const std::string FILE_DIR_4 = "testDir-4";
+const std::string FILE_NAME_1 = "testFile-1";
+const std::string FILE_NAME_2 = "testFile-2";
+
+struct Fixture {
+    utils::ScopedDir mTestPathGuard;
+    Fixture()
+        : mTestPathGuard(TEST_PATH)
+    {}
+};
 
 } // namespace
 
+BOOST_FIXTURE_TEST_SUITE(UtilsFSSuite, Fixture)
+
 BOOST_AUTO_TEST_CASE(ReadFileContentTest)
 {
-    BOOST_CHECK_EQUAL(FILE_CONTENT, readFileContent(FILE_PATH));
+    BOOST_CHECK_EQUAL(REFERENCE_FILE_CONTENT, readFileContent(REFERENCE_FILE_PATH));
     BOOST_CHECK_EXCEPTION(readFileContent(BUGGY_FILE_PATH),
                           UtilsException,
                           WhatEquals("Read failed"));
@@ -83,18 +82,15 @@ BOOST_AUTO_TEST_CASE(ReadFileContentTest)
 
 BOOST_AUTO_TEST_CASE(SaveFileContentTest)
 {
-    BOOST_REQUIRE(saveFileContent(FILE_PATH_RANDOM, FILE_CONTENT));
-    BOOST_CHECK_EQUAL(FILE_CONTENT, readFileContent(FILE_PATH));
-
-    boost::system::error_code ec;
-    boost::filesystem::remove(FILE_PATH_RANDOM, ec);
+    BOOST_REQUIRE(saveFileContent(FILE_PATH, REFERENCE_FILE_CONTENT));
+    BOOST_CHECK_EQUAL(REFERENCE_FILE_CONTENT, readFileContent(FILE_PATH));
 }
 
 BOOST_AUTO_TEST_CASE(RemoveFileTest)
 {
-    BOOST_REQUIRE(saveFileContent(FILE_PATH_RANDOM, FILE_CONTENT));
-    BOOST_REQUIRE(removeFile(FILE_PATH_RANDOM));
-    BOOST_REQUIRE(!boost::filesystem::exists(FILE_PATH_RANDOM));
+    BOOST_REQUIRE(saveFileContent(FILE_PATH, REFERENCE_FILE_CONTENT));
+    BOOST_REQUIRE(removeFile(FILE_PATH));
+    BOOST_REQUIRE(!boost::filesystem::exists(FILE_PATH));
 }
 
 BOOST_AUTO_TEST_CASE(MountPointTest)
@@ -103,20 +99,20 @@ BOOST_AUTO_TEST_CASE(MountPointTest)
     namespace fs = boost::filesystem;
     boost::system::error_code ec;
 
-    BOOST_REQUIRE(fs::create_directory(MOUNT_POINT_RANDOM_1, ec));
-    BOOST_REQUIRE(isMountPoint(MOUNT_POINT_RANDOM_1, result));
+    BOOST_REQUIRE(fs::create_directory(MOUNT_POINT_1, ec));
+    BOOST_REQUIRE(isMountPoint(MOUNT_POINT_1, result));
     BOOST_CHECK_EQUAL(result, false);
-    BOOST_REQUIRE(hasSameMountPoint(TMP_PATH, MOUNT_POINT_RANDOM_1, result));
+    BOOST_REQUIRE(hasSameMountPoint(TEST_PATH, MOUNT_POINT_1, result));
     BOOST_CHECK_EQUAL(result, true);
 
-    BOOST_REQUIRE(mountRun(MOUNT_POINT_RANDOM_1));
-    BOOST_REQUIRE(isMountPoint(MOUNT_POINT_RANDOM_1, result));
+    BOOST_REQUIRE(mountRun(MOUNT_POINT_1));
+    BOOST_REQUIRE(isMountPoint(MOUNT_POINT_1, result));
     BOOST_CHECK_EQUAL(result, true);
-    BOOST_REQUIRE(hasSameMountPoint(TMP_PATH, MOUNT_POINT_RANDOM_1, result));
+    BOOST_REQUIRE(hasSameMountPoint(TEST_PATH, MOUNT_POINT_1, result));
     BOOST_CHECK_EQUAL(result, false);
 
-    BOOST_REQUIRE(umount(MOUNT_POINT_RANDOM_1));
-    BOOST_REQUIRE(fs::remove(MOUNT_POINT_RANDOM_1, ec));
+    BOOST_REQUIRE(umount(MOUNT_POINT_1));
+    BOOST_REQUIRE(fs::remove(MOUNT_POINT_1, ec));
 }
 
 BOOST_AUTO_TEST_CASE(MoveFileTest)
@@ -126,32 +122,32 @@ BOOST_AUTO_TEST_CASE(MoveFileTest)
     std::string src, dst;
 
     // same mount point
-    src = TMP_PATH + "/" + FILE_NAME_RANDOM_1;
-    dst = TMP_PATH + "/" + FILE_NAME_RANDOM_2;
+    src = TEST_PATH + "/" + FILE_NAME_1;
+    dst = TEST_PATH + "/" + FILE_NAME_2;
 
-    BOOST_REQUIRE(saveFileContent(src, FILE_CONTENT));
+    BOOST_REQUIRE(saveFileContent(src, REFERENCE_FILE_CONTENT));
 
     BOOST_CHECK(moveFile(src, dst));
     BOOST_CHECK(!fs::exists(src));
-    BOOST_CHECK_EQUAL(readFileContent(dst), FILE_CONTENT);
+    BOOST_CHECK_EQUAL(readFileContent(dst), REFERENCE_FILE_CONTENT);
 
     BOOST_REQUIRE(fs::remove(dst));
 
     // different mount point
-    src = TMP_PATH + "/" + FILE_NAME_RANDOM_1;
-    dst = MOUNT_POINT_RANDOM_2 + "/" + FILE_NAME_RANDOM_2;
+    src = TEST_PATH + "/" + FILE_NAME_1;
+    dst = MOUNT_POINT_2 + "/" + FILE_NAME_2;
 
-    BOOST_REQUIRE(fs::create_directory(MOUNT_POINT_RANDOM_2, ec));
-    BOOST_REQUIRE(mountRun(MOUNT_POINT_RANDOM_2));
-    BOOST_REQUIRE(saveFileContent(src, FILE_CONTENT));
+    BOOST_REQUIRE(fs::create_directory(MOUNT_POINT_2, ec));
+    BOOST_REQUIRE(mountRun(MOUNT_POINT_2));
+    BOOST_REQUIRE(saveFileContent(src, REFERENCE_FILE_CONTENT));
 
     BOOST_CHECK(moveFile(src, dst));
     BOOST_CHECK(!fs::exists(src));
-    BOOST_CHECK_EQUAL(readFileContent(dst), FILE_CONTENT);
+    BOOST_CHECK_EQUAL(readFileContent(dst), REFERENCE_FILE_CONTENT);
 
     BOOST_REQUIRE(fs::remove(dst));
-    BOOST_REQUIRE(umount(MOUNT_POINT_RANDOM_2));
-    BOOST_REQUIRE(fs::remove(MOUNT_POINT_RANDOM_2, ec));
+    BOOST_REQUIRE(umount(MOUNT_POINT_2));
+    BOOST_REQUIRE(fs::remove(MOUNT_POINT_2, ec));
 }
 
 BOOST_AUTO_TEST_CASE(CopyDirContentsTest)
@@ -160,24 +156,24 @@ BOOST_AUTO_TEST_CASE(CopyDirContentsTest)
     std::string src, src_inner, src_inner2, dst, dst_inner, dst_inner2;
     boost::system::error_code ec;
 
-    src = TMP_PATH + "/" + FILE_DIR_RANDOM_1;
-    src_inner = src + "/" + FILE_DIR_RANDOM_3;
-    src_inner2 = src + "/" + FILE_DIR_RANDOM_4;
+    src = TEST_PATH + "/" + FILE_DIR_1;
+    src_inner = src + "/" + FILE_DIR_3;
+    src_inner2 = src + "/" + FILE_DIR_4;
 
-    dst = TMP_PATH + "/" + FILE_DIR_RANDOM_2;
-    dst_inner = dst + "/" + FILE_DIR_RANDOM_3;
-    dst_inner2 = dst + "/" + FILE_DIR_RANDOM_4;
+    dst = TEST_PATH + "/" + FILE_DIR_2;
+    dst_inner = dst + "/" + FILE_DIR_3;
+    dst_inner2 = dst + "/" + FILE_DIR_4;
 
     // template dir structure:
     // |-src
-    //    |-FILE_NAME_RANDOM_1
-    //    |-FILE_NAME_RANDOM_2
+    //    |-FILE_NAME_1
+    //    |-FILE_NAME_2
     //    |-src_inner (rw directory)
-    //    |  |-FILE_NAME_RANDOM_1
+    //    |  |-FILE_NAME_1
     //    |
     //    |-src_inner2 (ro directory)
-    //       |-FILE_NAME_RANDOM_1
-    //       |-FILE_NAME_RANDOM_2
+    //       |-FILE_NAME_1
+    //       |-FILE_NAME_2
 
     // create entire structure with files
     BOOST_REQUIRE(fs::create_directory(src, ec));
@@ -187,11 +183,11 @@ BOOST_AUTO_TEST_CASE(CopyDirContentsTest)
     BOOST_REQUIRE(fs::create_directory(src_inner2, ec));
     BOOST_REQUIRE(ec.value() == 0);
 
-    BOOST_REQUIRE(saveFileContent(src + "/" + FILE_NAME_RANDOM_1, FILE_CONTENT));
-    BOOST_REQUIRE(saveFileContent(src + "/" + FILE_NAME_RANDOM_2, FILE_CONTENT_2));
-    BOOST_REQUIRE(saveFileContent(src_inner + "/" + FILE_NAME_RANDOM_1, FILE_CONTENT_3));
-    BOOST_REQUIRE(saveFileContent(src_inner2 + "/" + FILE_NAME_RANDOM_1, FILE_CONTENT_3));
-    BOOST_REQUIRE(saveFileContent(src_inner2 + "/" + FILE_NAME_RANDOM_2, FILE_CONTENT_2));
+    BOOST_REQUIRE(saveFileContent(src + "/" + FILE_NAME_1, REFERENCE_FILE_CONTENT));
+    BOOST_REQUIRE(saveFileContent(src + "/" + FILE_NAME_2, FILE_CONTENT_2));
+    BOOST_REQUIRE(saveFileContent(src_inner + "/" + FILE_NAME_1, FILE_CONTENT_3));
+    BOOST_REQUIRE(saveFileContent(src_inner2 + "/" + FILE_NAME_1, FILE_CONTENT_3));
+    BOOST_REQUIRE(saveFileContent(src_inner2 + "/" + FILE_NAME_2, FILE_CONTENT_2));
 
     // change permissions of src_inner2 directory
     fs::permissions(src_inner2, fs::owner_read, ec);
@@ -205,19 +201,19 @@ BOOST_AUTO_TEST_CASE(CopyDirContentsTest)
     BOOST_CHECK(copyDirContents(src, dst));
 
     // check if copy is successful
-    BOOST_CHECK(fs::exists(dst + "/" + FILE_NAME_RANDOM_1));
-    BOOST_CHECK(fs::exists(dst + "/" + FILE_NAME_RANDOM_2));
+    BOOST_CHECK(fs::exists(dst + "/" + FILE_NAME_1));
+    BOOST_CHECK(fs::exists(dst + "/" + FILE_NAME_2));
     BOOST_CHECK(fs::exists(dst_inner));
-    BOOST_CHECK(fs::exists(dst_inner + "/" + FILE_NAME_RANDOM_1));
+    BOOST_CHECK(fs::exists(dst_inner + "/" + FILE_NAME_1));
     BOOST_CHECK(fs::exists(dst_inner2));
-    BOOST_CHECK(fs::exists(dst_inner2 + "/" + FILE_NAME_RANDOM_1));
-    BOOST_CHECK(fs::exists(dst_inner2 + "/" + FILE_NAME_RANDOM_2));
-
-    BOOST_CHECK_EQUAL(readFileContent(dst + "/" + FILE_NAME_RANDOM_1), FILE_CONTENT);
-    BOOST_CHECK_EQUAL(readFileContent(dst + "/" + FILE_NAME_RANDOM_2), FILE_CONTENT_2);
-    BOOST_CHECK_EQUAL(readFileContent(dst_inner + "/" + FILE_NAME_RANDOM_1), FILE_CONTENT_3);
-    BOOST_CHECK_EQUAL(readFileContent(dst_inner2 + "/" + FILE_NAME_RANDOM_1), FILE_CONTENT_3);
-    BOOST_CHECK_EQUAL(readFileContent(dst_inner2 + "/" + FILE_NAME_RANDOM_2), FILE_CONTENT_2);
+    BOOST_CHECK(fs::exists(dst_inner2 + "/" + FILE_NAME_1));
+    BOOST_CHECK(fs::exists(dst_inner2 + "/" + FILE_NAME_2));
+
+    BOOST_CHECK_EQUAL(readFileContent(dst + "/" + FILE_NAME_1), REFERENCE_FILE_CONTENT);
+    BOOST_CHECK_EQUAL(readFileContent(dst + "/" + FILE_NAME_2), FILE_CONTENT_2);
+    BOOST_CHECK_EQUAL(readFileContent(dst_inner + "/" + FILE_NAME_1), FILE_CONTENT_3);
+    BOOST_CHECK_EQUAL(readFileContent(dst_inner2 + "/" + FILE_NAME_1), FILE_CONTENT_3);
+    BOOST_CHECK_EQUAL(readFileContent(dst_inner2 + "/" + FILE_NAME_2), FILE_CONTENT_2);
 
     fs::file_status st = fs::status(fs::path(dst_inner2));
     BOOST_CHECK(fs::owner_read == st.permissions());