return id;
}
+/* LCOV_EXCL_START */
static char *__get_victim(GHashTable *hash)
{
GHashTableIter iter;
return victim_key;
}
+/* LCOV_EXCL_STOP */
static struct datacontrol_cert_info* __insert_hash(GHashTable *hash, const char *key,
bool is_map, cert_status_type status)
_LOGI("select_map_file : %s", select_map_file);
+/* LCOV_EXCL_START */
/* TODO - shoud be changed to solve security concerns */
result_fd = open(select_map_file, O_RDWR | O_CREAT, 0644);
if (result_fd == -1) {
__sql_remove_cursor(cursor);
return retval;
}
+/* LCOV_EXCL_STOP */
static void __sql_call_user_cb(data_control_h provider, int request_id,
datacontrol_request_type type, bool provider_result, const char *error,
free(info);
}
+/* LCOV_EXCL_START */
static void __free_consumer_info_by_name(const gchar *name)
{
datacontrol_consumer_info find_key;
_LOGI("__free_consumer_info done");
}
+/* LCOV_EXCL_STOP */
+
static int __check_consumer_cert(const char *provider_id,
const char *consumer_appid,
data_control_data_change_type_e type)
return DATA_CONTROL_ERROR_IO_ERROR;
}
+/* LCOV_EXCL_START */
while (SQLITE_ROW == sqlite3_step(stmt)) {
app_id = (char *)sqlite3_column_text(stmt, 0);
if (!app_id) {
__noti_consumer_app_list =
g_list_append(__noti_consumer_app_list, consumer_info);
}
+/* LCOV_EXCL_STOP */
sqlite3_reset(stmt);
sqlite3_finalize(stmt);
}
return DATA_CONTROL_ERROR_NONE;
}
-
+/* LCOV_EXCL_START */
/* 1. column count */
column_count = sqlite3_column_count(state);
if (_write_socket(fd, &column_count, sizeof(int), &nb) !=
return DATA_CONTROL_ERROR_NONE;
}
+/* LCOV_EXCL_STOP */
static int __send_get_value_result(int fd, bundle *b, void *data)
{
return retval;
}
+/* LCOV_EXCL_START */
EXPORT_API int data_control_provider_send_data_change_noti_by_data_id(
const char *data_id, data_control_data_change_type_e type, bundle *data)
{
}
return retval;
}
+/* LCOV_EXCL_STOP */
EXPORT_API int data_control_provider_foreach_data_change_consumer(
data_control_h provider,
return MOCK_HOOK_P1(GioMock, g_dbus_message_get_body, arg0);
}
-extern "C" guint g_dbus_connection_signal_subscribe(GDBusConnection* arg0,
- const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4,
- const gchar* arg5, GDBusSignalFlags arg6, GDBusSignalCallback arg7,
- gpointer arg8, GDestroyNotify arg9) {
- return MOCK_HOOK_P10(GioMock, g_dbus_connection_signal_subscribe,
- arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-}
-
-extern "C" void g_dbus_connection_send_message_with_reply(GDBusConnection* arg0,
- GDBusMessage* arg1, GDBusSendMessageFlags arg2, gint arg3,
- volatile guint32* arg4, GCancellable* arg5, GAsyncReadyCallback arg6,
- gpointer arg7) {
- return MOCK_HOOK_P8(GioMock, g_dbus_connection_send_message_with_reply,
- arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-}
-
extern "C" guint g_bus_watch_name_on_connection(
GDBusConnection* arg0, const gchar* arg1, GBusNameWatcherFlags arg2,
GBusNameAppearedCallback arg3, GBusNameVanishedCallback arg4,
arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
-extern "C" void g_bus_unwatch_name(guint arg0) {
- return MOCK_HOOK_P1(GioMock, g_bus_unwatch_name, arg0);
-}
-
extern "C" void g_dbus_connection_signal_unsubscribe(
GDBusConnection* arg0, guint arg1) {
return MOCK_HOOK_P2(GioMock, g_dbus_connection_signal_unsubscribe,
extern "C" gboolean g_source_remove(guint tag) {
return MOCK_HOOK_P1(GioMock, g_source_remove, tag);
}
+
+extern "C" gboolean g_dbus_connection_emit_signal(GDBusConnection* arg0,
+ const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4,
+ GVariant* arg5, GError** arg6) {
+ return MOCK_HOOK_P7(GioMock, g_dbus_connection_emit_signal,
+ arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+}
\ No newline at end of file
MOCK_METHOD7(g_dbus_connection_send_message_with_reply_sync,
GDBusMessage*(GDBusConnection*, GDBusMessage*, GDBusSendMessageFlags,
gint, volatile guint32*, GCancellable*, GError**));
- MOCK_METHOD10(g_dbus_connection_signal_subscribe,
- guint(GDBusConnection*, const gchar*, const gchar*, const gchar*,
- const gchar*, const gchar*, GDBusSignalFlags, GDBusSignalCallback,
- gpointer, GDestroyNotify));
- MOCK_METHOD8(g_dbus_connection_send_message_with_reply,
- void(GDBusConnection*, GDBusMessage*, GDBusSendMessageFlags, gint,
- volatile guint32*, GCancellable*, GAsyncReadyCallback, gpointer));
MOCK_METHOD7(g_bus_watch_name_on_connection,
guint(GDBusConnection*, const gchar*, GBusNameWatcherFlags,
GBusNameAppearedCallback, GBusNameVanishedCallback, gpointer,
GDestroyNotify));
- MOCK_METHOD1(g_bus_unwatch_name, void(guint));
MOCK_METHOD2(g_dbus_connection_signal_unsubscribe,
void(GDBusConnection*, guint));
MOCK_METHOD1(g_dbus_connection_get_unique_name, const gchar*(GDBusConnection*));
MOCK_METHOD1(g_source_remove, gboolean(guint));
+ MOCK_METHOD7(g_dbus_connection_emit_signal,
+ gboolean(GDBusConnection*, const gchar*, const gchar*, const gchar*,
+ const gchar*, GVariant*, GError**));
};
#endif // MOCK_GIO_MOCK_H_
+++ /dev/null
-/*
- * Copyright (c) 2020 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 "unistd_mock.h"
-#include "mock_hook.h"
-#include "test_fixture.h"
-
-extern "C" off_t lseek(int fd, off_t offset, int whence) {
- return MOCK_HOOK_P3(UnistdMock, lseek, fd, offset, whence);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 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 MOCK_UNISTD_MOCK_H_
-#define MOCK_UNISTD_MOCK_H_
-
-#include <gmock/gmock.h>
-#include <unistd.h>
-#include <aul.h>
-
-#include "module_mock.h"
-
-class UnistdMock : public virtual ModuleMock {
- public:
- virtual ~UnistdMock() {}
-
- MOCK_METHOD3(lseek, off_t(int, off_t, int));
-};
-
-#endif // MOCK_UNISTD_MOCK_H_
#include <memory>
#include "data_control.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
class Mocks : public ::testing::NiceMock<PkgmgrInfoMock>,
public ::testing::NiceMock<CynaraMock>,
public ::testing::NiceMock<AppSvcMock>,
- public ::testing::NiceMock<GioMock>,
- public ::testing::NiceMock<UnistdMock> {};
+ public ::testing::NiceMock<GioMock> {};
class DataControlBulkTest : public TestFixture {
public:
*/
#include <gtest/gtest.h>
-#include <aul.h>
#include <sqlite3.h>
#include <bundle_cpp.h>
#include <glib.h>
+#include <unistd.h>
+#include <aul.h>
#include "data_control.h"
#include "data_control_internal.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
val = DATA_CONTROL_SQL_COLUMN_TYPE_BLOB;
memcpy(buf, &val, count);
break;
+ case DATA_CONTROL_SQL_COLUMN_TYPE_NULL :
+ val = DATA_CONTROL_SQL_COLUMN_TYPE_NULL;
+ memcpy(buf, &val, count);
+ break;
default :
if (count == 4) {
val = count;
return count;
}
+extern "C" off_t lseek(int fd, off_t offset, int whence) {
+ return 0;
+}
+
extern "C" int aul_app_get_appid_bypid(int pid, char* appid, int len) {
int ret;
data_control_provider_handler_fn __cb;
-extern "C" int aul_set_data_control_provider_cb(
- data_control_provider_handler_fn handler) {
- __cb = handler;
- return 0;
-}
+char* __request_type = nullptr;
+char* __first_data = nullptr;
extern "C" bundle* bundle_decode_raw(const bundle_raw* r, const int len) {
bundle* b;
- const char *str_array[] = { "data_id", "bbb", "ccc" };
+ const char *str_array[] = { __first_data, "1", "WORD", "WORD = 'test'",
+ "WORD ASC", "1", "1" };
b = bundle_create();
- bundle_add_str(b, OSP_K_REQUEST_ID, "99");
+ bundle_add_str(b, OSP_K_REQUEST_ID, "2");
bundle_add_str(b, AUL_K_CALLER_APPID, "caller_appid");
- bundle_add_str(b, OSP_K_DATACONTROL_REQUEST_TYPE, "2");
+ bundle_add_str(b, OSP_K_DATACONTROL_REQUEST_TYPE, __request_type);
bundle_add_str(b, OSP_K_DATACONTROL_PROVIDER, "provider_id");
bundle_add_str(b, OSP_K_DATACONTROL_HANDLE_ID, "caller_handle_id");
+ bundle_add_str(b, OSP_K_DATACONTROL_DATA, "data_id");
bundle_add_str(b, "RESULT_PAGE_NUMBER", "1");
bundle_add_str(b, "MAX_COUNT_PER_PAGE", "1");
bundle_add_str(b, "RESULT_VALUE_COUNT", "1");
- bundle_add_str_array(b, OSP_K_ARG, str_array, 3);
+ bundle_add_str_array(b, OSP_K_ARG, str_array, 7);
return b;
}
+
+extern "C" int aul_set_data_control_provider_cb(
+ data_control_provider_handler_fn handler) {
+ __cb = handler;
+ return 0;
+}
+
extern "C" int sqlite3_reset(sqlite3_stmt* pStmt) {
return SQLITE_OK;
}
extern "C" int sqlite3_step(sqlite3_stmt* pStmt) {
return SQLITE_OK;
}
+
+typedef int(*execcb)(void*, int, char**, char**);
+extern "C" int sqlite3_exec(sqlite3* db, const char* sql, execcb cb,
+ void* data, char** err) {
+ return SQLITE_OK;
+}
+
+extern "C" int sqlite3_open_v2(const char* db, sqlite3** table, int rw,
+ const char* data) {
+ return SQLITE_OK;
+}
+
+GDBusSignalCallback __signal_cb;
+extern "C" guint g_dbus_connection_signal_subscribe(GDBusConnection* arg0,
+ const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4,
+ const gchar* arg5, GDBusSignalFlags arg6, GDBusSignalCallback arg7,
+ gpointer arg8, GDestroyNotify arg9) {
+ __signal_cb = arg7;
+ return 1;
+}
#include <memory>
#include "data_control.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
using ::testing::Return;
using ::testing::SetArgPointee;
+extern char* __first_data;
+
class Mocks : public ::testing::NiceMock<PkgmgrInfoMock>,
public ::testing::NiceMock<CynaraMock>,
public ::testing::NiceMock<AppSvcMock>,
- public ::testing::NiceMock<GioMock>,
- public ::testing::NiceMock<UnistdMock> {};
+ public ::testing::NiceMock<GioMock> {};
class DataControlMapTest : public TestFixture {
public:
virtual ~DataControlMapTest() {}
virtual void SetUp() {
+ __first_data = strdup("1");
}
virtual void TearDown() {
+ free(__first_data);
}
};
const char* error, void* user_data) {
}
+extern GIOFunc __io_func;
+extern gpointer __io_data;
+extern char* __request_type;
+
TEST_F(DataControlMapTest, map_test) {
int ret;
int req_id;
pkgmgrinfo_cert_compare_result_type_e res;
data_control_bulk_data_h bulk_data_h;
+ EXPECT_CALL(GetMock<AppSvcMock>(),
+ appsvc_run_service(_, _, _, _)).WillOnce(Return(0));
+
ret = data_control_map_create(&provider);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
EXPECT_NE(handle_id, 0);
map_cb = (data_control_map_response_cb*)malloc(sizeof(data_control_map_response_cb));
- ASSERT_NE(map_cb, nullptr);
+ EXPECT_NE(map_cb, nullptr);
map_cb->get_cb = _data_control_map_get_response_cb;
map_cb->set_cb = _data_control_map_set_response_cb;
SetArgPointee<4>(access),
Return(PMINFO_R_OK)));
+ __request_type = strdup("6");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("7");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("8");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("9");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("10");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+
ret = data_control_map_register_add_bulk_data_response_cb(
provider, _data_control_bulk_cb, NULL);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
map_cb = (data_control_map_response_cb*)malloc(sizeof(data_control_map_response_cb));
- ASSERT_NE(map_cb, nullptr);
+ EXPECT_NE(map_cb, nullptr);
map_cb->get_cb = _data_control_map_get_response_cb;
map_cb->set_cb = _data_control_map_set_response_cb;
#include <memory>
#include "data_control.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
using ::testing::DoAll;
using ::testing::Return;
using ::testing::SetArgPointee;
+using ::testing::InvokeArgument;
+
+extern GDBusSignalCallback __signal_cb;
class Mocks : public ::testing::NiceMock<PkgmgrInfoMock>,
public ::testing::NiceMock<CynaraMock>,
public ::testing::NiceMock<AppSvcMock>,
- public ::testing::NiceMock<GioMock>,
- public ::testing::NiceMock<UnistdMock> {};
+ public ::testing::NiceMock<GioMock> {};
class DataControlNotiTest : public TestFixture {
public:
int callback_id;
char* app_id;
data_control_h provider;
+ GVariant *param = g_variant_new("(isssi)", 1, "test_providerid",
+ "test_dataid", "raw", 3);
+ GVariant *param2 = g_variant_new("(iii)", 6, 1, 3);
ret = data_control_map_create(&provider);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
ret = data_control_map_set_data_id(provider, "test_dataid");
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
- EXPECT_CALL(GetMock<GioMock>(),
- g_dbus_connection_signal_subscribe(
- _, _, _, _, _, _, _, _, _, _)).
- WillOnce(Return(99));
-
app_id = (char*)malloc(sizeof(char) * 11);
ret = snprintf(app_id, 11, "%s", "test_appid");
_data_control_add_callback_result_cb, NULL, &callback_id);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+ __signal_cb(nullptr, "sender_name", "path", "name",
+ "noti_data_changed", param, nullptr);
+ __signal_cb(nullptr, "sender_name", "path", "name",
+ "noti_add_remove_result", param2, nullptr);
+
ret = data_control_remove_data_change_cb(provider, callback_id);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
#include <bundle.h>
#include <bundle_cpp.h>
#include <glib.h>
+#include <aul.h>
#include <memory>
#include "data_control.h"
+#include "data_control_internal.h"
#include "data_control_provider_internal.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
using ::testing::Return;
using ::testing::SetArgPointee;
+extern char* __first_data;
+
+
class Mocks : public ::testing::NiceMock<PkgmgrInfoMock>,
public ::testing::NiceMock<CynaraMock>,
public ::testing::NiceMock<AppSvcMock>,
- public ::testing::NiceMock<GioMock>,
- public ::testing::NiceMock<UnistdMock> {};
+ public ::testing::NiceMock<GioMock> {};
class DataControlProviderTest : public TestFixture {
public:
virtual ~DataControlProviderTest() {}
virtual void SetUp() {
+ __first_data = strdup("data_id");
}
virtual void TearDown() {
+ free(__first_data);
}
};
extern gpointer __io_data;
extern data_control_provider_handler_fn __cb;
+static int __request_id = 1;
+extern char* __request_type;
+
TEST_F(DataControlProviderTest, provider_register_map_cb_test) {
int ret;
data_control_provider_map_cb* map_cb;
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
+void _register_map_cb() {
+ int ret;
+ Bundle b;
+ data_control_provider_map_cb* map_cb;
+
+ map_cb = (data_control_provider_map_cb*) malloc(sizeof(data_control_provider_map_cb));
+ map_cb->get_cb = _data_control_provider_map_get_value_request_cb;
+ map_cb->set_cb = _data_control_provider_map_set_value_request_cb;
+ map_cb->add_cb = _data_control_provider_map_add_value_request_cb;
+ map_cb->remove_cb = _data_control_provider_map_remove_value_request_cb;
+
+ ret = data_control_provider_map_register_cb(map_cb, NULL);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string(AUL_K_CALLER_APPID), std::string("caller_appid"));
+ b.Add(std::string(AUL_K_CALLEE_APPID), std::string("callee_appid"));
+
+ __cb(b.GetHandle(), 1, NULL);
+
+ __io_func(nullptr, G_IO_IN, __io_data);
+
+ free(map_cb);
+
+ ret = data_control_provider_map_unregister_cb();
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
+void _register_map_cb_for_noti(const char* request_type) {
+ int ret;
+ Bundle b;
+ data_control_provider_map_cb* map_cb;
+
+ map_cb = (data_control_provider_map_cb*) malloc(sizeof(data_control_provider_map_cb));
+ map_cb->get_cb = _data_control_provider_map_get_value_request_cb;
+ map_cb->set_cb = _data_control_provider_map_set_value_request_cb;
+ map_cb->add_cb = _data_control_provider_map_add_value_request_cb;
+ map_cb->remove_cb = _data_control_provider_map_remove_value_request_cb;
+
+ ret = data_control_provider_map_register_cb(map_cb, NULL);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string(AUL_K_CALLER_APPID), std::string("caller_appid"));
+ b.Add(std::string(AUL_K_CALLEE_APPID), std::string("callee_appid"));
+
+ b.Add(std::string(AUL_K_CALLER_PID), std::string("5001"));
+ b.Add(std::string(OSP_K_DATACONTROL_UNIQUE_NAME), std::string("unique_id"));
+ b.Add(std::string(OSP_K_DATACONTROL_REQUEST_TYPE), request_type);
+ b.Add(std::string(OSP_K_DATACONTROL_PROVIDER), std::string("provider_id"));
+ b.Add(std::string(OSP_K_DATACONTROL_DATA), std::string("data_id"));
+ b.Add(std::string(OSP_K_DATA_CHANGED_CALLBACK_ID), std::string("11"));
+
+ __cb(b.GetHandle(), 1, NULL);
+
+ __io_func(nullptr, G_IO_IN, __io_data);
+
+ free(map_cb);
+
+ ret = data_control_provider_map_unregister_cb();
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
TEST_F(DataControlProviderTest, provider_send_select_result_test) {
int ret;
char* provider_appid = NULL;
WillOnce(DoAll(SetArgPointee<3>(res),
Return(PMINFO_R_OK)));
+ __request_type = strdup("1");
_register_sql_cb();
+ free(__request_type);
- ret = data_control_provider_get_client_appid(1, &appid);
+ ret = data_control_provider_get_client_appid(__request_id++, &appid);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
EXPECT_STREQ(appid, "caller_appid");
TEST_F(DataControlProviderTest, provider_send_insert_result_test) {
int ret;
+ __request_type = strdup("2");
_register_sql_cb();
+ free(__request_type);
- ret = data_control_provider_send_insert_result(2, 0);
+ ret = data_control_provider_send_insert_result(__request_id++, 0);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
TEST_F(DataControlProviderTest, provider_send_update_result_test) {
int ret;
+ __request_type = strdup("3");
_register_sql_cb();
+ free(__request_type);
- ret = data_control_provider_send_update_result(3);
+ ret = data_control_provider_send_update_result(__request_id++);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
}
TEST_F(DataControlProviderTest, provider_send_delete_result_test) {
int ret;
+ __request_type = strdup("4");
_register_sql_cb();
+ free(__request_type);
- ret = data_control_provider_send_delete_result(4);
+ ret = data_control_provider_send_delete_result(__request_id++);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
+
TEST_F(DataControlProviderTest, provider_send_error_result_test) {
int ret;
+ __request_type = strdup("5");
_register_sql_cb();
+ free(__request_type);
- ret = data_control_provider_send_error(5, "test_errors");
+ ret = data_control_provider_send_error(__request_id++, "test_errors");
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
TEST_F(DataControlProviderTest, provider_send_map_result_test) {
int ret;
- _register_sql_cb();
+ pkgmgrinfo_cert_compare_result_type_e res = PMINFO_CERT_COMPARE_MATCH;
+ char* provider_appid = NULL;
+ bool is_trusted = true;
- ret = data_control_provider_send_map_result(6);
+ EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
+ pkgmgrinfo_pkginfo_compare_usr_app_cert_info(_, _, _, _)).
+ WillOnce(DoAll(SetArgPointee<3>(res),
+ Return(PMINFO_R_OK)));
+ EXPECT_CALL(GetMock<PkgmgrInfoMock>(),
+ pkgmgrinfo_appinfo_usr_get_datacontrol_trusted_info(
+ _, _, _, _, _)).
+ WillOnce(DoAll(SetArgPointee<3>(provider_appid),
+ SetArgPointee<4>(is_trusted),
+ Return(PMINFO_R_OK)));
+
+ __request_type = strdup("6");
+ _register_map_cb();
+ free(__request_type);
+ ret = data_control_provider_send_map_result(__request_id++);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ //To improve coverage
+ __request_type = strdup("7");
+ _register_map_cb();
+ free(__request_type);
+ ret = data_control_provider_send_map_result(__request_id++);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ __request_type = strdup("8");
+ _register_map_cb();
+ free(__request_type);
+ ret = data_control_provider_send_map_result(__request_id++);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ __request_type = strdup("9");
+ _register_map_cb();
+ free(__request_type);
+ ret = data_control_provider_send_map_result(__request_id++);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ __request_type = strdup("10");
+ _register_map_cb();
+ free(__request_type);
+ ret = data_control_provider_send_map_result(__request_id++);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
value_list[0] = (char*)"val0";
value_list[1] = (char*)"val1";
- _register_sql_cb();
+ __request_type = strdup("10");
+ _register_map_cb();
+ free(__request_type);
- ret = data_control_provider_send_map_get_value_result(7, value_list, 2);
+ ret = data_control_provider_send_map_get_value_result(__request_id++, value_list, 2);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
int ret;
int fd;
+ __request_type = strdup("10");
_register_sql_cb();
+ free(__request_type);
- ret = datacontrol_provider_send_select_result_without_data(8, &fd);
+ ret = datacontrol_provider_send_select_result_without_data(__request_id++, &fd);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
int page_num;
int count_per_page;
+ __request_type = strdup("10");
_register_sql_cb();
+ free(__request_type);
- ret = datacontrol_provider_get_select_page_info(9, &page_num, &count_per_page);
+ ret = datacontrol_provider_get_select_page_info(__request_id++, &page_num, &count_per_page);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
}
+
+TEST_F(DataControlProviderTest, data_control_provider_send_bulk_insert_result) {
+ int ret;
+ Bundle b;
+ data_control_bulk_result_data_h result_data_h;
+
+ __request_type = strdup("10");
+ _register_map_cb();
+ free(__request_type);
+
+ ret = data_control_bulk_result_data_create(&result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string("testkey"), std::string("testvalue"));
+
+ ret = data_control_bulk_result_data_add(result_data_h, b.GetHandle(),
+ DATA_CONTROL_ERROR_NONE);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_provider_send_bulk_insert_result(__request_id++, result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_bulk_result_data_destroy(result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
+TEST_F(DataControlProviderTest, data_control_provider_send_map_bulk_add_result) {
+ int ret;
+ Bundle b;
+ data_control_bulk_result_data_h result_data_h;
+
+ __request_type = strdup("10");
+ _register_map_cb();
+ free(__request_type);
+
+ ret = data_control_bulk_result_data_create(&result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string("testkey"), std::string("testvalue"));
+
+ ret = data_control_bulk_result_data_add(result_data_h, b.GetHandle(),
+ DATA_CONTROL_ERROR_NONE);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_provider_send_map_bulk_add_result(__request_id++, result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_bulk_result_data_destroy(result_data_h);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
+TEST_F(DataControlProviderTest, provider_send_noti_test2) {
+ int ret;
+ Bundle b;
+ data_control_h provider;
+ GDBusMessage *msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
+ GDBusMessage *reply = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
+ GVariant *body = g_variant_new("(u)", 5001);
+
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_message_new_method_call(_, _, _, _)).
+ WillOnce(Return(msg));
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_connection_send_message_with_reply_sync(_, _, _, _, _, _, _)).
+ WillOnce(Return(reply));
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_message_get_body(_)).
+ WillOnce(Return(body));
+
+ __request_type = strdup("5");
+ _register_map_cb_for_noti("11");
+ free(__request_type);
+
+ ret = data_control_map_create(&provider);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_set_provider_id(provider, "test_providerid");
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_set_data_id(provider, "test_dataid");
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string("testkey"), std::string("testvalue"));
+
+ ret = data_control_provider_send_data_change_noti(provider,
+ DATA_CONTROL_DATA_CHANGE_MAP_SET, b.GetHandle());
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_destroy(provider);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
+
+TEST_F(DataControlProviderTest, provider_send_noti_test3) {
+ int ret;
+ Bundle b;
+ data_control_h provider;
+ GDBusMessage *msg = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
+ GDBusMessage *reply = (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr);
+ GVariant *body = g_variant_new("(u)", 5001);
+
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_message_new_method_call(_, _, _, _)).
+ WillOnce(Return(msg));
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_connection_send_message_with_reply_sync(_, _, _, _, _, _, _)).
+ WillOnce(Return(reply));
+ EXPECT_CALL(GetMock<GioMock>(),
+ g_dbus_message_get_body(_)).
+ WillOnce(Return(body));
+
+ __request_type = strdup("5");
+ _register_map_cb_for_noti("12");
+ free(__request_type);
+
+ ret = data_control_map_create(&provider);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_set_provider_id(provider, "test_providerid");
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_set_data_id(provider, "test_dataid");
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ b.Add(std::string("testkey"), std::string("testvalue"));
+
+ ret = data_control_provider_send_data_change_noti(provider,
+ DATA_CONTROL_DATA_CHANGE_MAP_SET, b.GetHandle());
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ ret = data_control_map_destroy(provider);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+}
\ No newline at end of file
#include "data_control.h"
#include "data_control_internal.h"
-#include "unistd_mock.h"
#include "pkgmgr_info_mock.h"
#include "cynara_mock.h"
#include "appsvc_mock.h"
using ::testing::Return;
using ::testing::SetArgPointee;
+extern char* __first_data;
+
class Mocks : public ::testing::NiceMock<PkgmgrInfoMock>,
public ::testing::NiceMock<CynaraMock>,
public ::testing::NiceMock<AppSvcMock>,
- public ::testing::NiceMock<GioMock>,
- public ::testing::NiceMock<UnistdMock> {};
+ public ::testing::NiceMock<GioMock> {};
class DataControlSqlTest : public TestFixture {
public:
virtual ~DataControlSqlTest() {}
virtual void SetUp() {
+ __first_data = strdup("1");
}
virtual void TearDown() {
+ free(__first_data);
}
};
const char* error, void* user_data) {
}
+extern GIOFunc __io_func;
+extern gpointer __io_data;
+extern char* __request_type;
+
TEST_F(DataControlSqlTest, sql_test) {
int ret;
int req_id;
free(data_id);
sql_cb = (data_control_sql_response_cb*)malloc(sizeof(data_control_sql_response_cb));
- ASSERT_NE(sql_cb, nullptr);
+ EXPECT_NE(sql_cb, nullptr);
sql_cb->select_cb = _data_control_sql_select_response_cb;
sql_cb->insert_cb = _data_control_sql_insert_response_cb;
SetArgPointee<4>(access),
Return(PMINFO_R_OK)));
+ __request_type = strdup("1");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("2");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("3");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("4");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+ __request_type = strdup("5");
+ __io_func(nullptr, G_IO_IN, __io_data);
+ free(__request_type);
+
ret = data_control_sql_register_insert_bulk_data_response_cb(provider,
_data_control_sql_bulk_cb, NULL);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
sql_cb = (data_control_sql_response_cb*)malloc(sizeof(data_control_sql_response_cb));
- ASSERT_NE(sql_cb, nullptr);
+ EXPECT_NE(sql_cb, nullptr);
sql_cb->select_cb = _data_control_sql_select_response_cb;
sql_cb->insert_cb = _data_control_sql_insert_response_cb;
ret = data_control_sql_get_column_item_size(cursor, 1);
EXPECT_EQ(ret, 4);
+ _cursor->resultset_fd = 1000;
+ ret = data_control_sql_get_column_item_type(cursor, 1, &type);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ _cursor->resultset_fd = 2000;
+ ret = data_control_sql_get_column_item_type(cursor, 1, &type);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ _cursor->resultset_fd = 3000;
+ ret = data_control_sql_get_column_item_type(cursor, 1, &type);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ _cursor->resultset_fd = 4000;
+ ret = data_control_sql_get_column_item_type(cursor, 1, &type);
+ EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
+
+ _cursor->resultset_fd = 5000;
ret = data_control_sql_get_column_item_type(cursor, 1, &type);
EXPECT_EQ(ret, DATA_CONTROL_ERROR_NONE);
projects / platform / core / appfw / data-control.git / commitdiff