INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
ADD_SUBDIRECTORY(test)
+IF(BUILD_GTESTS)
+ ADD_SUBDIRECTORY(gtest)
+ENDIF(BUILD_GTESTS)
IF(UNIX)
static void free_vpn_connection_ipv6(struct vpn_connection_ipv6 *ipv6_info);
static void free_vpn_connection_route(gpointer data);
+//LCOV_EXCL_START
enum dvpnlib_err
vpn_connection_set_user_routes(struct vpn_connection *connection,
struct vpn_connection_route **user_routes)
g_free(property_changed_cb);
}
+//LCOV_EXCL_STOP
void destroy_vpn_connections(void)
{
if (vpn_connection_list != NULL) {
- g_list_free(vpn_connection_list);
- vpn_connection_list = NULL;
+ g_list_free(vpn_connection_list); //LCOV_EXCL_LINE
+ vpn_connection_list = NULL; //LCOV_EXCL_LINE
}
if (vpn_connection_hash != NULL) {
g_hash_table_destroy(vpn_connection_hash);
}
}
+//LCOV_EXCL_START
static struct vpn_connection *create_vpn_connection(
gchar *object_path,
GVariantIter *properties)
g_free(connection);
}
+//LCOV_EXCL_STOP
static void create_vpn_connections(GVariant *connections)
{
return;
}
- while (g_variant_iter_loop(iter, "(oa{sv})", &path, &properties))
- create_vpn_connection(path, properties);
+ while (g_variant_iter_loop(iter, "(oa{sv})", &path, &properties)) //LCOV_EXCL_LINE
+ create_vpn_connection(path, properties); //LCOV_EXCL_LINE
- g_variant_iter_free(iter);
+ g_variant_iter_free(iter); //LCOV_EXCL_LINE
}
+//LCOV_EXCL_START
struct vpn_connection *get_connection_by_path(const gchar *path)
{
DBG("path: %s", path);
g_hash_table_remove(vpn_connection_hash,
(gconstpointer)connection->path);
}
+//LCOV_EXCL_STOP
void sync_vpn_connections(void)
{
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (connections == NULL) {
- ERROR("error info: %s", error->message);
- g_error_free(error);
- return;
+ ERROR("error info: %s", error->message); //LCOV_EXCL_LINE
+ g_error_free(error); //LCOV_EXCL_LINE
+ return; //LCOV_EXCL_LINE
}
print_str = g_variant_print(connections, TRUE);
return vpn_connection_list;
}
+//LCOV_EXCL_START
struct vpn_connection *vpn_get_connection(
const char *name, const char *host, const char *domain)
{
return DVPNLIB_ERR_NONE;
}
+//LCOV_EXCL_STOP
vpn_connection_removed_cb connection_removed_cb;
};
+//LCOV_EXCL_START
static void connection_added(GVariant *parameters)
{
struct vpn_connection *connection;
else if (!g_strcmp0(signal_name, "ConnectionRemoved"))
connection_removed(parameters);
}
+//LCOV_EXCL_STOP
void free_vpn_manager(struct vpn_manager *manager)
{
DBG("");
manager = g_try_new0(struct vpn_manager, 1);
if (manager == NULL) {
- ERROR("no memory");
- return NULL;
+ ERROR("no memory"); //LCOV_EXCL_LINE
+ return NULL; //LCOV_EXCL_LINE
}
manager->dbus_proxy = g_dbus_proxy_new_for_bus_sync(
VPN_MANAGER_INTERFACE, NULL, &error);
if (manager->dbus_proxy == NULL) {
- ERROR("error info: %s", error->message);
- g_error_free(error);
- free_vpn_manager(manager);
- return NULL;
+ ERROR("error info: %s", error->message); //LCOV_EXCL_LINE
+ g_error_free(error); //LCOV_EXCL_LINE
+ free_vpn_manager(manager); //LCOV_EXCL_LINE
+ return NULL; //LCOV_EXCL_LINE
}
g_signal_connect(manager->dbus_proxy, "g-signal",
return vpn_manager->dbus_proxy;
}
+//LCOV_EXCL_START
/**
* Asynchronous Methods Create/Remove callback
*/
vpn_manager->connection_removed_cb = NULL;
vpn_manager->connection_removed_cb_data = NULL;
}
-
+//LCOV_EXCL_STOP
vpn_manager = create_vpn_manager();
if (vpn_manager == NULL) {
- DBG("can't create vpn manager");
- return -1;
+ DBG("can't create vpn manager"); //LCOV_EXCL_LINE
+ return -1; //LCOV_EXCL_LINE
}
sync_vpn_connections();
#include "dvpnlib-internal.h"
+//LCOV_EXCL_START
/*
* D-Bus
*/
return DVPNLIB_ERR_FAILED;
}
+//LCOV_EXCL_STOP
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(gtest-vpn-settings C CXX)
+
+SET(GTEST_TEST "gtest-vpn-setting")
+ADD_DEFINITIONS("-DUSE_DLOG")
+
+SET(REQUIRES_LIST ${REQUIRES_LIST}
+ glib-2.0
+ gio-2.0
+ gmock
+ dlog
+)
+
+SET(REQUIRED_LIBS "-ldl")
+
+IF(BUILD_GCOV)
+ ADD_DEFINITIONS("-DTIZEN_TEST_GCOV")
+ SET(REQUIRED_LIBS "${REQUIRED_LIBS} -lgcov")
+ENDIF(BUILD_GCOV)
+
+INCLUDE(FindPkgConfig)
+PKG_CHECK_MODULES(GTEST_TEST_PKG REQUIRED ${REQUIRES_LIST})
+
+FOREACH(flag ${GTEST_TEST_PKG_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wall -fPIE")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}")
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed -pie")
+
+FILE(GLOB GTEST_TEST_SRCS *.cpp)
+SET(GTEST_TEST_SRCS ${GTEST_TEST_SRCS})
+
+ADD_EXECUTABLE(${GTEST_TEST} ${GTEST_TEST_SRCS})
+TARGET_LINK_LIBRARIES(${GTEST_TEST} ${GTEST_TEST_LDFLAGS} ${GTEST_TEST_PKG_LDFLAGS} ${fw_name} ${REQUIRED_LIBS})
+
+INSTALL(TARGETS ${GTEST_TEST} RUNTIME DESTINATION bin)
--- /dev/null
+//LCOV_EXCL_START
+
+#include <functional>
+#include "gtest-vpn-settings-common.h"
+
+GMainLoop *MainLoop::m_mainLoop = NULL;
+guint MainLoop::m_timerId = 0;
+
+MainLoop::MainLoop(void)
+{
+}
+
+MainLoop::~MainLoop(void)
+{
+ if (m_mainLoop)
+ g_main_loop_quit(m_mainLoop);
+ if (m_timerId)
+ g_source_remove(m_timerId);
+
+ m_mainLoop = NULL;
+ m_timerId = 0;
+}
+
+gboolean MainLoop::timeoutCb(gpointer data)
+{
+ if (m_mainLoop)
+ g_main_loop_quit(m_mainLoop);
+ if (m_timerId)
+ g_source_remove(m_timerId);
+
+ m_mainLoop = NULL;
+ m_timerId = 0;
+
+ return false;
+}
+
+void MainLoop::run(unsigned int timeout)
+{
+ if (m_timerId > 0)
+ return;
+
+ m_mainLoop = g_main_loop_new(NULL, false);
+ m_timerId = g_timeout_add_seconds(timeout,
+ (GSourceFunc) MainLoop::timeoutCb,
+ NULL);
+ g_main_loop_run(m_mainLoop);
+}
+
+void MainLoop::quit(void)
+{
+ timeoutCb(NULL);
+}
+
+//LCOV_EXCL_STOP
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 __GTEST_VPN_SETTING_COMMON_H__
+#define __GTEST_VPN_SETTING_COMMON_H__
+
+#include <glib.h>
+#include <vpn.h>
+
+#ifdef USE_DLOG
+#include <dlog.h>
+#undef LOG_TAG
+#define LOG_TAG "VPN_SETTING_TEST"
+#define GLOGD(format, args...) LOGD(format, ##args)
+#else
+#define GLOGD(format, args...)
+#endif
+
+typedef enum {
+ ERROR_NONE = VPN_ERROR_NONE,
+ ERROR_INVALID_PARAMETER = VPN_ERROR_INVALID_PARAMETER,
+ ERROR_OUT_OF_MEMORY = VPN_ERROR_OUT_OF_MEMORY,
+ ERROR_INVALID_OPERATION = VPN_ERROR_INVALID_OPERATION,
+ ERROR_ADDRESS_FAMILY_NOT_SUPPORTED = VPN_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED,
+ ERROR_OPERATION_FAILED = VPN_ERROR_OPERATION_FAILED,
+ ERROR_NO_CONNECTION = VPN_ERROR_NO_CONNECTION,
+ ERROR_NOW_IN_PROGRESS = VPN_ERROR_NOW_IN_PROGRESS,
+ ERROR_ALREADY_EXISTS = VPN_ERROR_ALREADY_EXISTS,
+ ERROR_OPERATION_ABORTED = VPN_ERROR_OPERATION_ABORTED,
+ ERROR_DHCP_FAILED = VPN_ERROR_DHCP_FAILED,
+ ERROR_INVALID_KEY = VPN_ERROR_INVALID_KEY,
+ ERROR_NO_REPLY = VPN_ERROR_NO_REPLY,
+ ERROR_SECURITY_RESTRICTED = VPN_ERROR_SECURITY_RESTRICTED
+} error_e;
+
+class MainLoop {
+private:
+ static GMainLoop *m_mainLoop;
+ static guint m_timerId;
+
+ static gboolean timeoutCb(gpointer data);
+public:
+ MainLoop(void);
+ ~MainLoop(void);
+ void run(unsigned int timeout);
+ void quit(void);
+};
+
+#endif /* __GTEST_VPN_SETTING_COMMON_H__ */
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+
+//LCOV_EXCL_START
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "gtest-vpn-settings.h"
+
+#ifdef TIZEN_TEST_GCOV
+extern "C" void __gcov_flush(void);
+#endif
+
+using ::testing::InitGoogleTest;
+using ::testing::Test;
+using ::testing::TestCase;
+
+TEST(VpnSetting, vpnInitialize_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnInitialize_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnInitialize_n)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnInitialize_n();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnDeinitialize_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDeinitialize_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnDeinitialize_n)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDeinitialize_n();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsInit_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsInit_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsInit_n)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsInit_n();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsDeinit_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsDeinit_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsDeinit_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsDeinit_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsDeinit_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsDeinit_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetSpecific_p1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetSpecific_p1();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetSpecific_p2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetSpecific_p2();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetSpecific_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetSpecific_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetSpecific_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetSpecific_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetSpecific_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetSpecific_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetType_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetType_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetType_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetType_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetType_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetType_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetName_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetName_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetName_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetName_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetName_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetName_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetHost_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetHost_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetHost_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetHost_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetHost_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetHost_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetDomain_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetDomain_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetDomain_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetDomain_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSettingsSetDomain_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSettingsSetDomain_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnCreate_p1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnCreate_p1();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnCreate_p2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnCreate_p2();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnCreate_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnCreate_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnCreate_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnCreate_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnRemove_p1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnRemove_p1();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnRemove_p2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnRemove_p2();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnRemove_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnRemove_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnRemove_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnRemove_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnRemove_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnRemove_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnConnect_p1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnConnect_p1();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnConnect_p2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnConnect_p2();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnConnect_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnConnect_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnConnect_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnConnect_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnConnect_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnConnect_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnDisconnect_p1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDisconnect_p1();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnDisconnect_p2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDisconnect_p2();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnDisconnect_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDisconnect_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnDisconnect_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDisconnect_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnDisconnect_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnDisconnect_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnGetVpnHandle_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n5)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n5();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandle_n6)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandle_n6();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnGetVpnInfoName_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoName_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoName_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoName_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoName_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoName_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoName_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoName_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoName_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoName_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnGetVpnInfoType_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoType_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoType_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoType_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoType_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoType_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoType_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoType_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoType_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoType_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnGetVpnInfoHost_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoHost_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoHost_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoHost_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoHost_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoHost_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoHost_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoHost_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoHost_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoHost_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnGetVpnInfoDomain_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoDomain_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoDomain_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoDomain_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoDomain_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoDomain_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoDomain_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoDomain_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnInfoDomain_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnInfoDomain_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandleList_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandleList_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnGetVpnHandleList_n)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnGetVpnHandleList_n();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnSetStateCallback_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSetStateCallback_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnSetStateCallback_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSetStateCallback_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnSetStateCallback_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSetStateCallback_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnSetStateCallback_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSetStateCallback_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnSetStateCallback_n4)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnSetStateCallback_n4();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, DISABLED_vpnUnsetStateCallback_p)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnUnsetStateCallback_p();
+ EXPECT_EQ(VPN_ERROR_NONE, ret);
+}
+
+TEST(VpnSetting, vpnUnsetStateCallback_n1)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnUnsetStateCallback_n1();
+ EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
+}
+
+TEST(VpnSetting, vpnUnsetStateCallback_n2)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnUnsetStateCallback_n2();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+TEST(VpnSetting, vpnUnsetStateCallback_n3)
+{
+ int ret;
+ VpnSetting vpn;
+
+ ret = vpn.vpnUnsetStateCallback_n3();
+ EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
+}
+
+int main(int argc, char **argv)
+{
+ int ret = 0;
+
+#ifdef TIZEN_TEST_GCOV
+ setenv("GCOV_PREFIX", "/tmp", 1);
+#endif
+
+ InitGoogleTest(&argc, argv);
+ ret = RUN_ALL_TESTS();
+
+#ifdef TIZEN_TEST_GCOV
+ __gcov_flush();
+#endif
+
+ return ret;
+}
+
+//LCOV_EXCL_STOP
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+
+//LCOV_EXCL_START
+
+#include "gtest-vpn-settings.h"
+
+#include <stdio.h>
+
+VpnSetting::VpnSetting(void)
+{
+}
+
+VpnSetting::~VpnSetting(void)
+{
+ vpn_initialize();
+
+ const char *name = NULL;
+ const char *type = NULL;
+ const char *host = NULL;
+ const char *domain = NULL;
+ GList *iter;
+ GList *handles = vpn_get_vpn_handle_list();
+ vpn_h handle = NULL;
+
+ for (iter = handles; iter != NULL; iter = iter->next) {
+ vpn_get_vpn_info_name(iter->data, &name);
+ vpn_get_vpn_info_type(iter->data, &type);
+ vpn_get_vpn_info_host(iter->data, &host);
+ vpn_get_vpn_info_domain(iter->data, &domain);
+ vpn_get_vpn_handle(name, host, domain, &handle);
+ vpn_remove(handle, NULL, NULL);
+ }
+
+ vpn_settings_deinit();
+ vpn_deinitialize();
+}
+
+int VpnSetting::vpnInitialize_p(void)
+{
+ return vpn_initialize();
+}
+
+int VpnSetting::vpnInitialize_n(void)
+{
+ vpn_initialize();
+ return vpn_initialize();
+}
+
+int VpnSetting::vpnDeinitialize_p(void)
+{
+ vpn_initialize();
+ return vpn_deinitialize();
+}
+
+int VpnSetting::vpnDeinitialize_n(void)
+{
+ return vpn_deinitialize();
+}
+
+int VpnSetting::vpnSettingsInit_p(void)
+{
+ vpn_initialize();
+ return vpn_settings_init();
+}
+
+int VpnSetting::vpnSettingsInit_n(void)
+{
+ return vpn_settings_init();
+}
+
+int VpnSetting::vpnSettingsDeinit_p(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_deinit();
+}
+
+int VpnSetting::vpnSettingsDeinit_n1(void)
+{
+ return vpn_settings_deinit();
+}
+
+int VpnSetting::vpnSettingsDeinit_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_deinit();
+}
+
+int VpnSetting::vpnSettingsSetSpecific_p1(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_specific("Vpn", "Settings");
+}
+
+int VpnSetting::vpnSettingsSetSpecific_p2(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_specific("Vpn", NULL);
+}
+
+int VpnSetting::vpnSettingsSetSpecific_n1(void)
+{
+ return vpn_settings_set_specific("Vpn", "Settings");
+}
+
+int VpnSetting::vpnSettingsSetSpecific_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_set_specific("Vpn", "Settings");
+}
+
+int VpnSetting::vpnSettingsSetSpecific_n3(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_specific(NULL, "Settings");
+}
+
+int VpnSetting::vpnSettingsSetType_p(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_type("openvpn");
+}
+
+int VpnSetting::vpnSettingsSetType_n1(void)
+{
+ return vpn_settings_set_type("openvpn");
+}
+
+int VpnSetting::vpnSettingsSetType_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_set_type("openvpn");
+}
+
+int VpnSetting::vpnSettingsSetName_p(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_name("Name");
+}
+
+int VpnSetting::vpnSettingsSetName_n1(void)
+{
+ return vpn_settings_set_name("Name");
+}
+
+int VpnSetting::vpnSettingsSetName_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_set_name("Name");
+}
+
+int VpnSetting::vpnSettingsSetHost_p(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_host("Host");
+}
+
+int VpnSetting::vpnSettingsSetHost_n1(void)
+{
+ return vpn_settings_set_host("Host");
+}
+
+int VpnSetting::vpnSettingsSetHost_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_set_host("Host");
+}
+
+int VpnSetting::vpnSettingsSetDomain_p(void)
+{
+ vpn_initialize();
+ vpn_settings_init();
+ return vpn_settings_set_domain("Domain");
+}
+
+int VpnSetting::vpnSettingsSetDomain_n1(void)
+{
+ return vpn_settings_set_domain("Domain");
+}
+
+int VpnSetting::vpnSettingsSetDomain_n2(void)
+{
+ vpn_initialize();
+ return vpn_settings_set_domain("Domain");
+}
+
+void VpnSetting::vpnCreatedCb(vpn_error_e result, void *data)
+{
+ vpn_error_e *vpnCreatedResult = (vpn_error_e *)data;
+ if (vpnCreatedResult)
+ *vpnCreatedResult = result;
+}
+
+int VpnSetting::vpnCreate_p1(void)
+{
+ MainLoop loop;
+ vpn_error_e vpnCreatedResult = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(VpnSetting::vpnCreatedCb, &vpnCreatedResult);
+ loop.run(1);
+ return vpnCreatedResult;
+}
+
+int VpnSetting::vpnCreate_p2(void)
+{
+ MainLoop loop;
+ int ret = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ ret = vpn_create(NULL, NULL);
+ loop.run(1);
+ return ret;
+}
+
+int VpnSetting::vpnCreate_n1(void)
+{
+ return vpn_create(VpnSetting::vpnCreatedCb, NULL);
+}
+
+int VpnSetting::vpnCreate_n2(void)
+{
+ vpn_initialize();
+ return vpn_create(VpnSetting::vpnCreatedCb, NULL);
+}
+
+void VpnSetting::vpnRemovedCb(vpn_error_e result, void *data)
+{
+ vpn_error_e *vpnRemovedResult = (vpn_error_e *)data;
+ if (vpnRemovedResult)
+ *vpnRemovedResult = result;
+}
+
+int VpnSetting::vpnRemove_p1(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ vpn_error_e vpnRemovedResult = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ vpn_remove(handle, VpnSetting::vpnRemovedCb, &vpnRemovedResult);
+ loop.run(1);
+ return vpnRemovedResult;
+}
+
+int VpnSetting::vpnRemove_p2(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ int ret = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ ret = vpn_remove(handle, NULL, NULL);
+ loop.run(1);
+ return ret;
+}
+
+int VpnSetting::vpnRemove_n1(void)
+{
+ return vpn_remove(NULL, VpnSetting::vpnRemovedCb, NULL);
+}
+
+int VpnSetting::vpnRemove_n2(void)
+{
+ vpn_initialize();
+ return vpn_remove(NULL, VpnSetting::vpnRemovedCb, NULL);
+}
+
+int VpnSetting::vpnRemove_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_remove(&handle, VpnSetting::vpnRemovedCb, NULL);
+}
+
+void VpnSetting::vpnConnectedCb(vpn_error_e result, void *data)
+{
+ vpn_error_e *vpnConnectedResult = (vpn_error_e *)data;
+ if (vpnConnectedResult)
+ *vpnConnectedResult = result;
+}
+
+int VpnSetting::vpnConnect_p1(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ vpn_error_e vpnConnectedResult = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ vpn_connect(handle, VpnSetting::vpnConnectedCb, &vpnConnectedResult);
+ loop.run(1);
+ return vpnConnectedResult;
+}
+
+int VpnSetting::vpnConnect_p2(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ int ret = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ ret = vpn_connect(handle, NULL, NULL);
+ loop.run(1);
+ return ret;
+}
+
+int VpnSetting::vpnConnect_n1(void)
+{
+ return vpn_connect(NULL, VpnSetting::vpnConnectedCb, NULL);
+}
+
+int VpnSetting::vpnConnect_n2(void)
+{
+ vpn_initialize();
+ return vpn_connect(NULL, VpnSetting::vpnConnectedCb, NULL);
+}
+
+int VpnSetting::vpnConnect_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_connect(&handle, VpnSetting::vpnConnectedCb, NULL);
+}
+
+void VpnSetting::vpnDisconnectedCb(vpn_error_e result, void *data)
+{
+ vpn_error_e *vpnDisconnectedResult = (vpn_error_e *)data;
+ if (vpnDisconnectedResult)
+ *vpnDisconnectedResult = result;
+}
+
+int VpnSetting::vpnDisconnect_p1(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ vpn_error_e vpnDisconnectedResult = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ vpn_connect(handle, NULL, NULL);
+ loop.run(1);
+ vpn_disconnect(handle, VpnSetting::vpnDisconnectedCb, &vpnDisconnectedResult);
+ return vpnDisconnectedResult;
+}
+
+int VpnSetting::vpnDisconnect_p2(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ int ret = VPN_ERROR_NONE;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ ret = vpn_connect(handle, NULL, NULL);
+ loop.run(1);
+ vpn_disconnect(handle, NULL, NULL);
+ return ret;
+}
+
+int VpnSetting::vpnDisconnect_n1(void)
+{
+ return vpn_disconnect(NULL, VpnSetting::vpnDisconnectedCb, NULL);
+}
+
+int VpnSetting::vpnDisconnect_n2(void)
+{
+ vpn_initialize();
+ return vpn_disconnect(NULL, VpnSetting::vpnDisconnectedCb, NULL);
+}
+
+int VpnSetting::vpnDisconnect_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_disconnect(&handle, VpnSetting::vpnDisconnectedCb, NULL);
+}
+
+int VpnSetting::vpnGetVpnHandle_p(void)
+{
+ MainLoop loop;
+ int ret = VPN_ERROR_NONE;
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ ret = vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return ret;
+}
+
+int VpnSetting::vpnGetVpnHandle_n1(void)
+{
+ vpn_h handle = NULL;
+
+ return vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+}
+
+int VpnSetting::vpnGetVpnHandle_n2(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_handle(NULL, "Host", "Domain", &handle);
+}
+
+int VpnSetting::vpnGetVpnHandle_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_handle("Name", NULL, "Domain", &handle);
+}
+
+int VpnSetting::vpnGetVpnHandle_n4(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_handle("Name", "Host", NULL, &handle);
+}
+
+int VpnSetting::vpnGetVpnHandle_n5(void)
+{
+ vpn_initialize();
+ return vpn_get_vpn_handle("Name", "Host", "Domain", NULL);
+}
+
+int VpnSetting::vpnGetVpnHandle_n6(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+}
+
+int VpnSetting::vpnGetVpnInfoName_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ const char *name = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_get_vpn_info_name(handle, &name);
+}
+
+int VpnSetting::vpnGetVpnInfoName_n1(void)
+{
+ vpn_h handle = NULL;
+ const char *name = NULL;
+
+ return vpn_get_vpn_info_name(handle, &name);
+}
+
+int VpnSetting::vpnGetVpnInfoName_n2(void)
+{
+ vpn_h handle = NULL;
+ const char *name = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_name(handle, &name);
+}
+
+int VpnSetting::vpnGetVpnInfoName_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_name(handle, NULL);
+}
+
+int VpnSetting::vpnGetVpnInfoName_n4(void)
+{
+ vpn_h handle = NULL;
+ const char *name = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_name(&handle, &name);
+}
+
+int VpnSetting::vpnGetVpnInfoType_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ const char *type = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_get_vpn_info_type(handle, &type);
+}
+
+int VpnSetting::vpnGetVpnInfoType_n1(void)
+{
+ vpn_h handle = NULL;
+ const char *type = NULL;
+
+ return vpn_get_vpn_info_type(handle, &type);
+}
+
+int VpnSetting::vpnGetVpnInfoType_n2(void)
+{
+ vpn_h handle = NULL;
+ const char *type = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_type(handle, &type);
+}
+
+int VpnSetting::vpnGetVpnInfoType_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_type(handle, NULL);
+}
+
+int VpnSetting::vpnGetVpnInfoType_n4(void)
+{
+ vpn_h handle = NULL;
+ const char *type = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_type(&handle, &type);
+}
+
+int VpnSetting::vpnGetVpnInfoHost_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ const char *host = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_get_vpn_info_host(handle, &host);
+}
+
+int VpnSetting::vpnGetVpnInfoHost_n1(void)
+{
+ vpn_h handle = NULL;
+ const char *host = NULL;
+
+ return vpn_get_vpn_info_host(handle, &host);
+}
+
+int VpnSetting::vpnGetVpnInfoHost_n2(void)
+{
+ vpn_h handle = NULL;
+ const char *host = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_host(handle, &host);
+}
+
+int VpnSetting::vpnGetVpnInfoHost_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_host(handle, NULL);
+}
+
+int VpnSetting::vpnGetVpnInfoHost_n4(void)
+{
+ vpn_h handle = NULL;
+ const char *host = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_host(&handle, &host);
+}
+
+int VpnSetting::vpnGetVpnInfoDomain_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+ const char *domain = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_get_vpn_info_domain(handle, &domain);
+}
+
+int VpnSetting::vpnGetVpnInfoDomain_n1(void)
+{
+ vpn_h handle = NULL;
+ const char *domain = NULL;
+
+ return vpn_get_vpn_info_domain(handle, &domain);
+}
+
+int VpnSetting::vpnGetVpnInfoDomain_n2(void)
+{
+ vpn_h handle = NULL;
+ const char *domain = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_domain(handle, &domain);
+}
+
+int VpnSetting::vpnGetVpnInfoDomain_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_domain(handle, NULL);
+}
+
+int VpnSetting::vpnGetVpnInfoDomain_n4(void)
+{
+ vpn_h handle = NULL;
+ const char *domain = NULL;
+
+ vpn_initialize();
+ return vpn_get_vpn_info_domain(&handle, &domain);
+}
+
+int VpnSetting::vpnGetVpnHandleList_p(void)
+{
+ vpn_initialize();
+ vpn_get_vpn_handle_list();
+ return VPN_ERROR_NONE;
+}
+
+int VpnSetting::vpnGetVpnHandleList_n(void)
+{
+ vpn_get_vpn_handle_list();
+ return VPN_ERROR_INVALID_OPERATION;
+}
+
+void VpnSetting::vpnStateCb(const vpn_h handle, vpn_state_e state,
+ void *user_data)
+{
+}
+
+int VpnSetting::vpnSetStateCallback_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_set_state_callback(handle, VpnSetting::vpnStateCb, NULL);
+}
+
+int VpnSetting::vpnSetStateCallback_n1(void)
+{
+ return vpn_set_state_callback(NULL, NULL, NULL);
+}
+
+int VpnSetting::vpnSetStateCallback_n2(void)
+{
+ vpn_initialize();
+ return vpn_set_state_callback(NULL, VpnSetting::vpnStateCb, NULL);
+}
+
+int VpnSetting::vpnSetStateCallback_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_set_state_callback(&handle, NULL, NULL);
+}
+
+int VpnSetting::vpnSetStateCallback_n4(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_set_state_callback(&handle, VpnSetting::vpnStateCb, NULL);
+}
+
+int VpnSetting::vpnUnsetStateCallback_p(void)
+{
+ MainLoop loop;
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ vpn_settings_init();
+ vpn_settings_set_type("openvpn");
+ vpn_settings_set_name("Name");
+ vpn_settings_set_host("Host");
+ vpn_settings_set_domain("Domain");
+ vpn_create(NULL, NULL);
+ loop.run(1);
+ vpn_get_vpn_handle("Name", "Host", "Domain", &handle);
+ return vpn_unset_state_callback(handle);
+}
+
+int VpnSetting::vpnUnsetStateCallback_n1(void)
+{
+ return vpn_unset_state_callback(NULL);
+}
+
+int VpnSetting::vpnUnsetStateCallback_n2(void)
+{
+ vpn_initialize();
+ return vpn_unset_state_callback(NULL);
+}
+
+int VpnSetting::vpnUnsetStateCallback_n3(void)
+{
+ vpn_h handle = NULL;
+
+ vpn_initialize();
+ return vpn_unset_state_callback(&handle);
+}
+
+//LCOV_EXCL_STOP
--- /dev/null
+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 __VPN_SETTING_H__
+#define __VPN_SETTING_H__
+
+#include <glib.h>
+#include <vpn.h>
+#include "gtest-vpn-settings-common.h"
+
+class VpnSetting {
+private:
+ static void vpnCreatedCb(vpn_error_e result, void *data);
+ static void vpnRemovedCb(vpn_error_e result, void *data);
+ static void vpnConnectedCb(vpn_error_e result, void *data);
+ static void vpnDisconnectedCb(vpn_error_e result, void *data);
+ static void vpnStateCb(const vpn_h handle, vpn_state_e state,
+ void *user_data);
+public:
+ VpnSetting(void);
+ ~VpnSetting(void);
+ int vpnInitialize_p(void);
+ int vpnInitialize_n(void);
+ int vpnDeinitialize_p(void);
+ int vpnDeinitialize_n(void);
+ int vpnSettingsInit_p(void);
+ int vpnSettingsInit_n(void);
+ int vpnSettingsDeinit_p(void);
+ int vpnSettingsDeinit_n1(void);
+ int vpnSettingsDeinit_n2(void);
+ int vpnSettingsSetSpecific_p1(void);
+ int vpnSettingsSetSpecific_p2(void);
+ int vpnSettingsSetSpecific_n1(void);
+ int vpnSettingsSetSpecific_n2(void);
+ int vpnSettingsSetSpecific_n3(void);
+ int vpnSettingsSetType_p(void);
+ int vpnSettingsSetType_n1(void);
+ int vpnSettingsSetType_n2(void);
+ int vpnSettingsSetName_p(void);
+ int vpnSettingsSetName_n1(void);
+ int vpnSettingsSetName_n2(void);
+ int vpnSettingsSetHost_p(void);
+ int vpnSettingsSetHost_n1(void);
+ int vpnSettingsSetHost_n2(void);
+ int vpnSettingsSetDomain_p(void);
+ int vpnSettingsSetDomain_n1(void);
+ int vpnSettingsSetDomain_n2(void);
+ int vpnCreate_p1(void);
+ int vpnCreate_p2(void);
+ int vpnCreate_n1(void);
+ int vpnCreate_n2(void);
+ int vpnRemove_p1(void);
+ int vpnRemove_p2(void);
+ int vpnRemove_n1(void);
+ int vpnRemove_n2(void);
+ int vpnRemove_n3(void);
+ int vpnConnect_p1(void);
+ int vpnConnect_p2(void);
+ int vpnConnect_n1(void);
+ int vpnConnect_n2(void);
+ int vpnConnect_n3(void);
+ int vpnDisconnect_p1(void);
+ int vpnDisconnect_p2(void);
+ int vpnDisconnect_n1(void);
+ int vpnDisconnect_n2(void);
+ int vpnDisconnect_n3(void);
+ int vpnGetVpnHandle_p(void);
+ int vpnGetVpnHandle_n1(void);
+ int vpnGetVpnHandle_n2(void);
+ int vpnGetVpnHandle_n3(void);
+ int vpnGetVpnHandle_n4(void);
+ int vpnGetVpnHandle_n5(void);
+ int vpnGetVpnHandle_n6(void);
+ int vpnGetVpnInfoName_p(void);
+ int vpnGetVpnInfoName_n1(void);
+ int vpnGetVpnInfoName_n2(void);
+ int vpnGetVpnInfoName_n3(void);
+ int vpnGetVpnInfoName_n4(void);
+ int vpnGetVpnInfoType_p(void);
+ int vpnGetVpnInfoType_n1(void);
+ int vpnGetVpnInfoType_n2(void);
+ int vpnGetVpnInfoType_n3(void);
+ int vpnGetVpnInfoType_n4(void);
+ int vpnGetVpnInfoHost_p(void);
+ int vpnGetVpnInfoHost_n1(void);
+ int vpnGetVpnInfoHost_n2(void);
+ int vpnGetVpnInfoHost_n3(void);
+ int vpnGetVpnInfoHost_n4(void);
+ int vpnGetVpnInfoDomain_p(void);
+ int vpnGetVpnInfoDomain_n1(void);
+ int vpnGetVpnInfoDomain_n2(void);
+ int vpnGetVpnInfoDomain_n3(void);
+ int vpnGetVpnInfoDomain_n4(void);
+ int vpnGetVpnHandleList_p(void);
+ int vpnGetVpnHandleList_n(void);
+ int vpnSetStateCallback_p(void);
+ int vpnSetStateCallback_n1(void);
+ int vpnSetStateCallback_n2(void);
+ int vpnSetStateCallback_n3(void);
+ int vpnSetStateCallback_n4(void);
+ int vpnUnsetStateCallback_p(void);
+ int vpnUnsetStateCallback_n1(void);
+ int vpnUnsetStateCallback_n2(void);
+ int vpnUnsetStateCallback_n3(void);
+};
+#endif /* __VPN_SETTING_H__ */
Name: capi-network-vpn-setting
Summary: Default VPN Library
-Version: 0.1.2
+Version: 0.1.3
Release: 1
Group: System/Network
License: Apache-2.0
BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(capi-base-common)
BuildRequires: pkgconfig(libtzplatform-config)
+
+%if 0%{?gtests:1}
+BuildRequires: pkgconfig(gmock)
+%endif
+
+%if 0%{?gcov:1}
+BuildRequires: lcov
+%endif
+
%if "%{ipsec_test}" == "yes"
BuildRequires: openssl
cp %{SOURCE1001} .
%build
+%if 0%{?gcov:1}
+export CFLAGS+=" -fprofile-arcs -ftest-coverage"
+export CXXFLAGS+=" -fprofile-arcs -ftest-coverage"
+export LDFLAGS+=" -lgcov"
+%endif
+
MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
%cmake . \
%if "%{ipsec_test}" == "yes"
-DHOST_CERT_EXAMPLES=%host_cert_examples \
-DCA_CERTS_DIR=%ca_certs_dir \
%endif
+%if 0%{?gtests:1}
+ -DBUILD_GTESTS=%{?gtests:1}%{!?gtests:0} \
+%endif
+%if 0%{?gcov:1}
+ -DBUILD_GCOV=%{?gcov:1}%{!?gcov:0} \
+%endif
-DFULLVER=%{version} \
-DMAJORVER=${MAJORVER}
%manifest %{name}.manifest
%attr(644,-,-) %{_libdir}/libcapi-network-vpn-setting.so.*
%license LICENSE.APLv2
+%if 0%{?gtests:1}
+%attr(500, network_fw, network_fw) %{_bindir}/gtest*
+%endif
%files devel
%manifest %{name}.manifest
%files test
%manifest %{name}.manifest
-%{_libdir}/vpn_setting_test
%{_bindir}/vpn_setting_test
%if "%{ipsec_test}" == "yes"
%{cert_examples}/*
static struct _vpn_cb_s vpn_callbacks = {0,};
static GHashTable *settings_hash;
+//LCOV_EXCL_START
/*
* Utility Functions
*/
return VPN_ERROR_OPERATION_FAILED;
}
}
+//LCOV_EXCL_STOP
/*
*Functions Actually use Default VPN Library
return false;
vpn_callbacks.state_cb_datas = g_hash_table_new_full(g_direct_hash,
- g_direct_equal,
- NULL,
- NULL);
+ g_direct_equal,
+ NULL,
+ NULL);
return true;
}
int _vpn_settings_init()
{
if (settings_hash != NULL) {
- VPN_LOG(VPN_INFO,
- "Settings Hash: %p Already present!", settings_hash);
- return VPN_ERROR_INVALID_OPERATION;
+ VPN_LOG(VPN_INFO, "Settings Hash: %p Already present!", settings_hash); //LCOV_EXCL_LINE
+ return VPN_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
}
settings_hash = g_hash_table_new_full(
if (key == NULL)
return VPN_ERROR_INVALID_PARAMETER;
+ if (settings_hash == NULL)
+ return VPN_ERROR_INVALID_OPERATION;
+
if (g_hash_table_contains(settings_hash, key)) {
+//LCOV_EXCL_START
if (value == NULL) {
VPN_LOG(VPN_INFO, "Settings Hash: %p {%s=%s} (Removed)",
settings_hash, key,
g_hash_table_remove(settings_hash, key);
return VPN_ERROR_NONE;
}
+//LCOV_EXCL_STOP
}
g_hash_table_replace(settings_hash,
return VPN_ERROR_NONE;
}
+//LCOV_EXCL_START
/*
*Callbacks
*/
__vpn_remove_cb(_dvpnlib_error2vpn_error(result));
}
+//LCOV_EXCL_STOP
int _vpn_create(vpn_created_cb callback, void *user_data)
{
if (!settings_hash)
return VPN_ERROR_INVALID_OPERATION;
+//LCOV_EXCL_START
VPN_LOG(VPN_INFO, "");
vpn_callbacks.create_cb = callback;
return _dvpnlib_error2vpn_error(err);
return VPN_ERROR_NONE;
+//LCOV_EXCL_STOP
}
return VPN_ERROR_INVALID_PARAMETER;
}
- const char *path = vpn_connection_get_path(handle);
- err = dvpnlib_vpn_manager_remove(path, vpn_manager_remove_cb, NULL);
- if (err != DVPNLIB_ERR_NONE)
- return _dvpnlib_error2vpn_error(err);
+ const char *path = vpn_connection_get_path(handle); //LCOV_EXCL_LINE
+ err = dvpnlib_vpn_manager_remove(path, vpn_manager_remove_cb, NULL); //LCOV_EXCL_LINE
+ if (err != DVPNLIB_ERR_NONE) //LCOV_EXCL_LINE
+ return _dvpnlib_error2vpn_error(err); //LCOV_EXCL_LINE
return VPN_ERROR_NONE;
}
+//LCOV_EXCL_START
/*
*Connect Disconnect Callbacks
*/
__vpn_connect_cb(_dvpnlib_error2vpn_error(result));
}
+//LCOV_EXCL_STOP
/*
*Connect to VPN Profile
return VPN_ERROR_INVALID_PARAMETER;
}
- enum vpn_connection_state state = vpn_connection_get_state(handle);
- if (state == VPN_CONN_STATE_READY)
- return VPN_ERROR_ALREADY_EXISTS;
+ enum vpn_connection_state state = vpn_connection_get_state(handle); //LCOV_EXCL_LINE
+ if (state == VPN_CONN_STATE_READY) //LCOV_EXCL_LINE
+ return VPN_ERROR_ALREADY_EXISTS; //LCOV_EXCL_LINE
- err = vpn_connection_connect(handle, vpn_manager_connect_cb, NULL);
- if (err != DVPNLIB_ERR_NONE)
- return _dvpnlib_error2vpn_error(err);
+ err = vpn_connection_connect(handle, vpn_manager_connect_cb, NULL); //LCOV_EXCL_LINE
+ if (err != DVPNLIB_ERR_NONE) //LCOV_EXCL_LINE
+ return _dvpnlib_error2vpn_error(err); //LCOV_EXCL_LINE
return VPN_ERROR_NONE;
}
return VPN_ERROR_INVALID_PARAMETER;
}
- enum vpn_connection_state state = vpn_connection_get_state(handle);
- if (state != VPN_CONN_STATE_READY)
- return VPN_ERROR_NO_CONNECTION;
+ enum vpn_connection_state state = vpn_connection_get_state(handle); //LCOV_EXCL_LINE
+ if (state != VPN_CONN_STATE_READY) //LCOV_EXCL_LINE
+ return VPN_ERROR_NO_CONNECTION; //LCOV_EXCL_LINE
- err = vpn_connection_disconnect(handle);
- if (err != DVPNLIB_ERR_NONE)
- return _dvpnlib_error2vpn_error(err);
+ err = vpn_connection_disconnect(handle); //LCOV_EXCL_LINE
+ if (err != DVPNLIB_ERR_NONE) //LCOV_EXCL_LINE
+ return _dvpnlib_error2vpn_error(err); //LCOV_EXCL_LINE
return VPN_ERROR_NONE;
}
return VPN_ERROR_INVALID_PARAMETER;
}
- *handle = connection;
- return VPN_ERROR_NONE;
+ *handle = connection; //LCOV_EXCL_LINE
+ return VPN_ERROR_NONE; //LCOV_EXCL_LINE
}
/*
return VPN_ERROR_INVALID_PARAMETER;
}
- *name = vpn_connection_get_name(handle);
- return VPN_ERROR_NONE;
+ *name = vpn_connection_get_name(handle); //LCOV_EXCL_LINE
+ return VPN_ERROR_NONE; //LCOV_EXCL_LINE
}
/*
return VPN_ERROR_INVALID_PARAMETER;
}
- *type = vpn_connection_get_type(handle);
- return VPN_ERROR_NONE;
+ *type = vpn_connection_get_type(handle); //LCOV_EXCL_LINE
+ return VPN_ERROR_NONE; //LCOV_EXCL_LINE
}
/*
return VPN_ERROR_INVALID_PARAMETER;
}
- *host = vpn_connection_get_host(handle);
- return VPN_ERROR_NONE;
+ *host = vpn_connection_get_host(handle); //LCOV_EXCL_LINE
+ return VPN_ERROR_NONE; //LCOV_EXCL_LINE
}
/*
return VPN_ERROR_INVALID_PARAMETER;
}
- *domain = vpn_connection_get_domain(handle);
- return VPN_ERROR_NONE;
+ *domain = vpn_connection_get_domain(handle); //LCOV_EXCL_LINE
+ return VPN_ERROR_NONE; //LCOV_EXCL_LINE
}
+//LCOV_EXCL_START
/*
*State Callbacks
*/
__vpn_state_cb(connection, user_data);
}
+//LCOV_EXCL_STOP
/*
*Set state changed callback to VPN handle
return VPN_ERROR_INVALID_PARAMETER;
}
- g_hash_table_replace(vpn_callbacks.state_cb_datas, handle, cb);
- err = vpn_connection_set_property_changed_cb(handle, VPN_CONN_PROP_STATE, vpn_manager_state_cb, (void *)user_data);
- if (err != DVPNLIB_ERR_NONE)
- return _dvpnlib_error2vpn_error(err);
+ g_hash_table_replace(vpn_callbacks.state_cb_datas, handle, cb); //LCOV_EXCL_LINE
+ err = vpn_connection_set_property_changed_cb(handle, VPN_CONN_PROP_STATE, vpn_manager_state_cb, (void *)user_data); //LCOV_EXCL_LINE
+ if (err != DVPNLIB_ERR_NONE) //LCOV_EXCL_LINE
+ return _dvpnlib_error2vpn_error(err); //LCOV_EXCL_LINE
return VPN_ERROR_NONE;
}
return VPN_ERROR_INVALID_PARAMETER;
}
- err = vpn_connection_unset_property_changed_cb(handle, VPN_CONN_PROP_STATE);
- if (err != DVPNLIB_ERR_NONE)
- return _dvpnlib_error2vpn_error(err);
+ err = vpn_connection_unset_property_changed_cb(handle, VPN_CONN_PROP_STATE); //LCOV_EXCL_LINE
+ if (err != DVPNLIB_ERR_NONE) //LCOV_EXCL_LINE
+ return _dvpnlib_error2vpn_error(err); //LCOV_EXCL_LINE
return VPN_ERROR_NONE;
}
}
if (_vpn_init() == false) {
- VPN_LOG(VPN_ERROR, "Init failed!\n");
- return VPN_ERROR_OPERATION_FAILED;
+ VPN_LOG(VPN_ERROR, "Init failed!\n"); //LCOV_EXCL_LINE
+ return VPN_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
}
is_init = true;
rv = _vpn_settings_init();
if (rv != VPN_ERROR_NONE)
- VPN_LOG(VPN_ERROR, "Error!! VPN Settings Deinit failed.\n");
+ VPN_LOG(VPN_ERROR, "Error!! VPN Settings Deinit failed.\n"); //LCOV_EXCL_LINE
return rv;
}
MESSAGE("${fw_test}")
ADD_EXECUTABLE(${fw_test} ${src})
TARGET_LINK_LIBRARIES(${fw_test} ${fw_name} ${${fw_test}_LDFLAGS})
- INSTALL(TARGETS ${fw_test} DESTINATION ${LIB_INSTALL_DIR}/vpn_setting_test/)
INSTALL(TARGETS ${fw_test} RUNTIME DESTINATION bin/)
ENDFOREACH()
IF(IPSEC_TEST)
ADD_SUBDIRECTORY(ipsec_test)
-ENDIF(IPSEC_TEST)
\ No newline at end of file
+ENDIF(IPSEC_TEST)
projects / platform / core / api / vpn-setting.git / commitdiff