## Target modules
SET(TARGET_ESD_MOD_CION "esd-mod-cion")
SET(TARGET_ESD_MOD_DBUS_EVENT "esd-mod-dbus-event")
+SET(TARGET_ESD_MOD_CION_UNITTESTS "esd-mod-cion-unittests")
+SET(TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS "esd-mod-dbus-event-unittests")
#ENABLE_TESTING()
#SET(TARGET_ESD_UNIT_TESTS "esd-unit-tests")
PKG_CHECK_MODULES(PKGMGR_DEPS REQUIRED pkgmgr)
PKG_CHECK_MODULES(EVENTSYSTEM_DEPS REQUIRED eventsystem)
PKG_CHECK_MODULES(DATABASE_DEPS REQUIRED tizen-database)
+PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock)
+PKG_CHECK_MODULES(APPSVC_DEPS REQUIRED appsvc)
ADD_SUBDIRECTORY(src)
IF(NOT DEFINED MINIMUM_BUILD)
ADD_SUBDIRECTORY(tests)
ENABLE_TESTING()
-SET(UNIT_TESTS ${PROJECT_NAME}-unittests)
-ADD_TEST(NAME ${UNIT_TESTS} COMMAND ${UNIT_TESTS})
-ADD_DEPENDENCIES(${UNIT_TESTS} ${PROJECT_NAME})
+ADD_TEST(NAME ${TARGET_ESD_MOD_CION_UNITTESTS} COMMAND ${TARGET_ESD_MOD_CION_UNITTESTS})
+ADD_DEPENDENCIES(${TARGET_ESD_MOD_CION_UNITTESTS} ${PROJECT_NAME})
+
+ADD_TEST(NAME ${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} COMMAND ${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS})
+ADD_DEPENDENCIES(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} ${PROJECT_NAME})
ENDIF(NOT DEFINED MINIMUM_BUILD)
test_main() {
echo "test_main start"
- /usr/bin/%{name}-unittests
+ /usr/bin/esd-mod-cion-unittests
+ /usr/bin/esd-mod-dbus_event-unittests
}
teardown() {
# unittests
#################################################
%files -n %{name}-unittests
-%{_bindir}/%{name}-unittests
+%{_bindir}/esd-*-unittests
%{_bindir}/tizen-unittests/%{name}/run-unittest.sh
std::shared_ptr<ParamsBase>>(name, std::make_shared<T>(cmd)));
}
+ void Unregister(std::string name) {
+ fmap_.erase(std::move(name));
+ }
+
template <class... ArgTypes>
bool Invoke(std::string name, ArgTypes... args) {
using ParamsType = Params<ArgTypes...>;
} // namespace
bool CionModule::Startup(api::ToolBox* tools) {
+ tools_ = tools;
tools->GetMethodBroker().Register("Cion.GetUuidWithGenerate",
api::Params<const std::string&, std::optional<std::string>&>(
[this](const std::string& appid, std::optional<std::string>& uuid) {
}
void CionModule::Shutdown() {
-
+ if (!tools_)
+ return;
+ tools_->GetMethodBroker().Unregister("Cion.GetUuidWithGenerate");
+ tools_->GetMethodBroker().Unregister("Cion.SetDisplayName");
+ tools_->GetMethodBroker().Unregister("Cion.GetDisplayName");
+ tools_->GetMethodBroker().Unregister("Cion.SetEnabled");
+ tools_->GetMethodBroker().Unregister("Cion.GetEnabled");
+ tools_ = nullptr;
}
bool CionModule::Init() {
try {
tizen_base::Database db(DBPATH, SQLITE_OPEN_READWRITE);
std::string uuid_str;
- int ret = 0;
+ bool ret = true;
if (!GetUuidFromDb(db, appid, uuid_str)) {
uuid_str = GenUuid();
_E("get uuid generate");
}
- if (ret == 0)
+ if (ret)
uuid = std::move(uuid_str);
+ else
+ uuid = std::nullopt;
} catch(const std::runtime_error&) {
uuid = std::nullopt;
}
tizen_base::Database db(DBPATH, SQLITE_OPEN_READWRITE);
std::string uuid;
- ret = 0;
+ bool result;
+ ret = -1;
if (!GetUuidFromDb(db, appid, uuid)) {
uuid = GenUuid();
- ret = SetUuidToDb(db, appid, uuid);
- if (ret != 0)
+ result = SetUuidToDb(db, appid, uuid);
+ if (!result) {
return;
+ }
}
auto q = tizen_base::Database::Sql(
.Bind(service_name)
.Bind(appid);
auto r = db.Exec(q);
- if (!static_cast<bool>(r))
- ret = -1;
+ if (static_cast<bool>(r))
+ ret = 0;
} catch(const std::runtime_error&) {
ret = -1;
}
auto q2 = tizen_base::Database::Sql(
"SELECT display_name FROM cion_display_name "
- "WHERE appid = %Q AND service_name = %Q")
+ "WHERE appid = ? AND service_name = ?")
.Bind(appid)
.Bind(service_name);
bool Startup(api::ToolBox* tools) override;
void Shutdown() override;
-
- void AddEnabledApp(const std::string& service_name,
- const std::string& app_id, const std::string& display_name);
- void RemoveEnabledApp(const std::string& service_name,
- const std::string& app_id);
std::optional<std::list<CionServiceInfo>> GetEnabledServiceList();
void GetUuidWithGenerate(const std::string& appid,
std::optional<std::string>& uuid);
private:
bool Init();
bool DbInit();
+ void AddEnabledApp(const std::string& service_name,
+ const std::string& app_id, const std::string& display_name);
+ void RemoveEnabledApp(const std::string& service_name,
+ const std::string& app_id);
void ChangeListenStatusCionServer();
void SetDisplayName(const std::string& appid,
const std::string& service_name,
private:
std::shared_ptr<CionOndemandServer> esd_cion_server_;
bool is_listening_ = false;
+ api::ToolBox* tools_ = nullptr;
};
} // namespace esd::module
CAPI_SYSTEM_INFO_DEPS
PKGMGR_DEPS
EVENTSYSTEM_DEPS
+ APPSVC_DEPS
)
INSTALL(TARGETS ${TARGET_ESD_MOD_DBUS_EVENT} DESTINATION ${ESD_MODULES_DIR}/mod
-ADD_SUBDIRECTORY(unit_tests)
+ADD_SUBDIRECTORY(cion_unit_tests)
+ADD_SUBDIRECTORY(dbus_event_unit_tests)
--- /dev/null
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules/cion/ ESD_MOD_CION_SRCS)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/lib/ ESD_LIB_SRCS)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src/ ESD_MOD_CION_TEST_SRCS)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock/ ESD_MOD_CION_MOCK_SRCS)\r
+ADD_EXECUTABLE(${TARGET_ESD_MOD_CION_UNITTESTS}\r
+ ${ESD_MOD_CION_SRCS}\r
+ ${ESD_LIB_SRCS}\r
+ ${ESD_MOD_CION_TEST_SRCS}\r
+ ${ESD_MOD_CION_MOCK_SRCS}\r
+)\r
+\r
+TARGET_INCLUDE_DIRECTORIES(${TARGET_ESD_MOD_CION_UNITTESTS} PUBLIC\r
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules)\r
+TARGET_INCLUDE_DIRECTORIES(${TARGET_ESD_MOD_CION_UNITTESTS} PUBLIC\r
+ ${CMAKE_CURRENT_SOURCE_DIR}/../mock)\r
+\r
+TARGET_LINK_LIBRARIES(${TARGET_ESD_MOD_CION_UNITTESTS} PRIVATE ${TARGET_LIB_ESD})\r
+\r
+APPLY_PKG_CONFIG(${TARGET_ESD_MOD_CION_UNITTESTS} PUBLIC\r
+ AUL_DEPS\r
+ BUNDLE_DEPS\r
+ PARCEL_DEPS\r
+ PKGMGR_INFO_DEPS\r
+ DLOG_DEPS\r
+ GIO_DEPS\r
+ GLIB_DEPS\r
+ CION_DEPS\r
+ VCONF_DEPS\r
+ CAPI_SYSTEM_INFO_DEPS\r
+ LIBTZPLATFORM_CONFIG_DEPS\r
+ UUID_DEPS\r
+ SQLITE3_DEPS\r
+ DATABASE_DEPS\r
+ SECURITY_MANAGER_DEPS\r
+ CYNARA_CLIENT_DEPS\r
+ CYNARA_CREDS_DBUS_DEPS\r
+ CYNARA_SESSION_DEPS\r
+ GMOCK_DEPS\r
+)\r
+\r
+INSTALL(TARGETS ${TARGET_ESD_MOD_CION_UNITTESTS} DESTINATION bin)\r
--- /dev/null
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include "cion/cion_module.hh"
+#include "pkgmgr_info_mock.h"
+#include "tzplatform_config_mock.h"
+#include "test_fixture.h"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+namespace {
+
+class Mocks : public ::testing::NiceMock<TzplatformConfigMock>,
+ public ::testing::NiceMock<PkgmgrInfoMock> {};
+
+const char *__fake_tzplatform_mkpath(enum tzplatform_variable id, const char *path) {
+ return ".cion_test.db";
+}
+
+} //namespace
+
+class CionModuleTest : public TestFixture {
+ public:
+ CionModuleTest() : TestFixture(std::make_unique<Mocks>()) {}
+ virtual ~CionModuleTest() {}
+
+ virtual void SetUp() {
+ remove(".cion_test.db");
+ tools_ = std::make_unique<esd::api::ToolBox>();
+ mod_ = std::make_unique<esd::module::CionModule>();
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+ mod_->Startup(tools_.get());
+ }
+
+ virtual void TearDown() {
+ mod_->Shutdown();
+ mod_.reset();
+ tools_.reset();
+ }
+
+ std::unique_ptr<esd::module::CionModule> mod_;
+ std::unique_ptr<esd::api::ToolBox> tools_;
+};
+
+TEST_F(CionModuleTest, GetUuidWithGenerate) {
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+
+ std::string app_id = "org.tizen.test";
+ std::optional<std::string> uuid;
+ bool ret = tools_->GetMethodBroker()
+ .Invoke<const std::string&, std::optional<std::string>&>(
+ "Cion.GetUuidWithGenerate", app_id, uuid);
+ EXPECT_TRUE(ret);
+ EXPECT_TRUE(uuid);
+}
+
+TEST_F(CionModuleTest, SetDisplayNameGetDisplayName) {
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+
+ std::string app_id = "org.tizen.test";
+ std::string service_name = "test_service";
+ std::string display_name = "TEST_SERVICE";
+ int ret = -1;
+ bool r = tools_->GetMethodBroker()
+ .Invoke<const std::string&, const std::string&,
+ const std::string&, int&>(
+ "Cion.SetDisplayName", app_id, service_name, display_name, ret);
+ EXPECT_TRUE(r);
+ EXPECT_EQ(ret, 0);
+
+ ret = -1;
+ std::string result_display_name;
+ r = tools_->GetMethodBroker()
+ .Invoke<const std::string&, const std::string&,
+ std::string&, int&>(
+ "Cion.GetDisplayName", app_id, service_name, result_display_name,
+ ret);
+ EXPECT_TRUE(r);
+ EXPECT_EQ(ret, 0);
+ EXPECT_EQ(display_name, result_display_name);
+}
+
+TEST_F(CionModuleTest, SetEnabledGetEnabled) {
+ EXPECT_CALL(GetMock<TzplatformConfigMock>(), tzplatform_mkpath(_, _))
+ .WillRepeatedly(Invoke(__fake_tzplatform_mkpath));
+ EXPECT_CALL(GetMock<PkgmgrInfoMock>(), pkgmgrinfo_pkginfo_get_version(_, _))
+ .WillRepeatedly(Invoke([](pkgmgrinfo_pkginfo_h handle, char** version) {
+ *version = const_cast<char*>("1.0.0");
+ return PMINFO_R_OK;
+ }));
+
+ std::string app_id = "org.tizen.test";
+ std::string service_name = "test_service";
+ std::string display_name = "TEST_SERVICE";
+ int ret = -1;
+ bool r = tools_->GetMethodBroker()
+ .Invoke<const std::string&, const std::string&,
+ const std::string&, int&>(
+ "Cion.SetDisplayName", app_id, service_name, display_name, ret);
+ ASSERT_EQ(ret, 0);
+
+ bool enabled = true;
+ ret = -1;
+ r = tools_->GetMethodBroker()
+ .Invoke<const std::string&, const std::string&, bool, int&>(
+ "Cion.SetEnabled", app_id, service_name, enabled, ret);
+ EXPECT_TRUE(r);
+ EXPECT_EQ(ret, 0);
+
+ ret = -1;
+ std::string result_display_name;
+ bool result_enabled = false;
+ r = tools_->GetMethodBroker()
+ .Invoke<const std::string&, const std::string&, bool&, int&>(
+ "Cion.GetEnabled", app_id, service_name, result_enabled, ret);
+ EXPECT_TRUE(r);
+ EXPECT_EQ(ret, 0);
+ EXPECT_EQ(enabled, result_enabled);
+}
--- /dev/null
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules/dbus_event/ ESD_MOD_DBUS_EVENT_SRC)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/lib/ ESD_LIB_SRCS)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src/ ESD_MOD_DBUS_EVENT_TEST_SRCS)\r
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock/ ESD_MOD_DBUS_EVENT_MOCK_SRCS)\r
+ADD_EXECUTABLE(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS}\r
+ ${ESD_MOD_DBUS_EVENT_SRC}\r
+ ${ESD_LIB_SRCS}\r
+ ${ESD_MOD_DBUS_EVENT_TEST_SRCS}\r
+ ${ESD_MOD_DBUS_EVENT_MOCK_SRCS}\r
+)\r
+\r
+TARGET_INCLUDE_DIRECTORIES(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} PUBLIC\r
+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules)\r
+TARGET_INCLUDE_DIRECTORIES(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} PUBLIC\r
+ ${CMAKE_CURRENT_SOURCE_DIR}/../mock)\r
+\r
+TARGET_LINK_LIBRARIES(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} PRIVATE ${TARGET_LIB_ESD})\r
+\r
+APPLY_PKG_CONFIG(${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} PUBLIC\r
+ AUL_DEPS\r
+ DLOG_DEPS\r
+ GIO_DEPS\r
+ GLIB_DEPS\r
+ VCONF_DEPS\r
+ PKGMGR_INFO_DEPS\r
+ SECURITY_MANAGER_DEPS\r
+ CYNARA_CLIENT_DEPS\r
+ CYNARA_CREDS_DBUS_DEPS\r
+ CYNARA_SESSION_DEPS\r
+ LIBTZPLATFORM_CONFIG_DEPS\r
+ CERT_SVC_VCORE_DEPS\r
+ CAPI_SYSTEM_INFO_DEPS\r
+ PKGMGR_DEPS\r
+ EVENTSYSTEM_DEPS\r
+ GMOCK_DEPS\r
+ APPSVC_DEPS\r
+)\r
+\r
+INSTALL(TARGETS ${TARGET_ESD_MOD_DBUS_EVENT_UNITTESTS} DESTINATION bin)\r
--- /dev/null
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+int main(int argc, char** argv) {
+ int ret = -1;
+
+ try {
+ testing::InitGoogleTest(&argc, argv);
+ } catch(...) {
+ std::cout << "Exception occurred" << std::endl;
+ }
+
+ try {
+ ret = RUN_ALL_TESTS();
+ } catch (const ::testing::internal::GoogleTestFailureException& e) {
+ ret = -1;
+ std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;
+ }
+
+ return ret;
+}
#include "cynara_mock.h"
#include "security_manager_mock.h"
#include "test_fixture.h"
-#include "privilege_checker.hh"
+#include "dbus_event/privilege_checker.hh"
// using namespace tizen_base;
#include "test_fixture.h"
#include "eventsystem_mock.h"
-#include "vconf_event_handler.hh"
+#include "dbus_event/vconf_event_handler.hh"
// using namespace tizen_base;
using ::testing::_;
--- /dev/null
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cion/channel/server_channel.hh>
+#include <cion/common/ipayload.hh>
+#include <cion/common/exception.hh>
+
+namespace cion {
+namespace channel {
+
+class ServerChannel::Impl {
+};
+
+ServerChannel::ServerChannel(std::string service_name, std::string display_name) {
+}
+
+ServerChannel::ServerChannel(std::string service_name, std::string display_name,
+ SecurityInfo security) {
+}
+
+ServerChannel::~ServerChannel() = default;
+
+void ServerChannel::Listen() {
+
+}
+
+void ServerChannel::Stop() {
+
+}
+
+void ServerChannel::Disconnect(std::shared_ptr<PeerInfo>) {
+
+}
+
+void ServerChannel::Accept(std::shared_ptr<PeerInfo> peer) {
+
+}
+
+void ServerChannel::Reject(std::shared_ptr<PeerInfo> peer, std::string reason) {
+
+}
+
+void ServerChannel::SendPayloadAsync(IPayload* data,
+ PayloadAsyncResult::PayloadAsyncResultCallback func) {
+}
+
+void ServerChannel::SendPayloadAsync(IPayload* data, std::shared_ptr<PeerInfo> peer,
+ PayloadAsyncResult::PayloadAsyncResultCallback func) {
+}
+
+std::list<std::shared_ptr<PeerInfo>> ServerChannel::GetConnectedPeerList() {
+ return {};
+}
+
+std::string GetServiceName() {
+ return "";
+}
+
+std::string GetDisplayName() {
+ return "";
+}
+
+void SetDisplayName(std::string display_name) {
+}
+
+void SetOndemandLaunchEnable(bool enable) {
+}
+
+}
+}
arg2, arg3);
}
+extern "C" int pkgmgrinfo_pkginfo_get_version(pkgmgrinfo_pkginfo_h handle,
+ char** version) {
+ return MOCK_HOOK_P2(PkgmgrInfoMock, pkgmgrinfo_pkginfo_get_version,
+ handle, version);
+}
int (pkgmgrinfo_pkginfo_h));
MOCK_METHOD3(pkgmgrinfo_appinfo_get_usr_appinfo,
int (const char *, uid_t, pkgmgrinfo_appinfo_h*));
+ MOCK_METHOD2(pkgmgrinfo_pkginfo_get_version,
+ int (pkgmgrinfo_pkginfo_h, char**));
};
#endif // MOCK_PKMGR_INFO_MOCK_H_
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tzplatform_config_mock.h"
+
+#include "mock_hook.h"
+#include "test_fixture.h"
+
+extern "C" const char* tzplatform_mkpath(enum tzplatform_variable arg1, const char* arg2) {
+ return MOCK_HOOK_P2(TzplatformConfigMock, tzplatform_mkpath, arg1, arg2);
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UNIT_TESTS_MOCK_TZPLATFORM_CONFIG_MOCK_H_
+#define UNIT_TESTS_MOCK_TZPLATFORM_CONFIG_MOCK_H_
+
+#include <tzplatform_config.h>
+#include <gmock/gmock.h>
+
+#include "module_mock.h"
+
+class TzplatformConfigMock : public virtual ModuleMock {
+ public:
+ TzplatformConfigMock() {
+ using ::testing::_;
+ using ::testing::Return;
+ using ::testing::Invoke;
+ }
+
+ MOCK_METHOD2(tzplatform_mkpath, const char* (enum tzplatform_variable,
+ const char*));
+};
+
+#endif // UNIT_TESTS_MOCK_TZPLATFORM_CONFIG_MOCK_H_
\ No newline at end of file
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)\r
-PROJECT(${PROJECT_NAME}-unittests C CXX)\r
-\r
-INCLUDE(FindPkgConfig)\r
-PKG_CHECK_MODULES(${PROJECT_NAME}-unittests REQUIRED\r
- aul\r
- bundle\r
- parcel\r
- dlog\r
- pkgmgr-info\r
- appsvc\r
- gio-2.0\r
- glib-2.0\r
- pkgmgr\r
- eventsystem\r
- vconf\r
- libtzplatform-config\r
- systemd\r
- cert-svc-vcore\r
- cynara-client\r
- cynara-creds-gdbus\r
- cynara-session\r
- security-manager\r
- uuid\r
- sqlite3\r
- cion\r
- capi-system-info\r
- gmock\r
-)\r
-\r
-FOREACH(flag ${${PROJECT_NAME}-unittests_CFLAGS})\r
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")\r
-ENDFOREACH(flag)\r
-SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden -Wall -Werror")\r
-\r
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++17")\r
-SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")\r
-SET(CMAKE_CXX_FLAGS_RELEASE "-O2")\r
-\r
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include)\r
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src/lib)\r
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules/dbus_event)\r
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../mock)\r
-\r
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src TEST_SOURCES)\r
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock MOCK_SOURCES)\r
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/lib LIB_SOURCES)\r
-AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../src/modules/dbus_event DBUS_SOURCES)\r
-\r
-ADD_EXECUTABLE(${PROJECT_NAME}\r
- ${TEST_SOURCES}\r
- ${LIB_SOURCES}\r
- ${DBUS_SOURCES}\r
- ${MOCK_SOURCES}\r
-)\r
-\r
-SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES COMPILE_FLAGS "${EXTRA_CFLAGS}")\r
-TARGET_LINK_LIBRARIES(${PROJECT_NAME}\r
- ${${PROJECT_NAME}-unittests_LDFLAGS}\r
-)\r
-\r
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION /usr/bin/)\r
projects / platform / core / appfw / event-system.git / commitdiff