#include "unittest.h"
#include "alarm.h"
-#include "mock/gio.h"
+#include "mock/gio_fake.h"
#include "mock/alarm_dbus.h"
#include "mock/aul_fake.h"
#include "mock/notification_fake.h"
{
GVariant *noti_gv = NULL;
- noti_gv = g_variant_new("(s)", "test");
+ noti_gv = g_variant_new_string("test");
return noti_gv;
}
--- /dev/null
+/*
+ * Copyright (c) 2019 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.
+ */
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "alarm.h"
+#include "alarm-internal.h"
+
+#include "alarm-manager.c"
+#include "alarm-manager-schedule.c"
+#include "alarm-manager-timer.c"
+#include "alarm-manager-registry.c"
+
+#include "mock/alarm_dbus.h"
+#include "mock/cynara_fake.h"
+#include "mock/gio_fake.h"
+#include "mock/glib_fake.h"
+
+GVariant* __fake_g_dbus_connection_call_sync(GDBusConnection *connection,
+ const gchar *bus_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *method_name,
+ GVariant *parameters,
+ const GVariantType *reply_type,
+ GDBusCallFlags flags,
+ gint timeout_msec,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GVariant* ret = g_variant_new_string("var");
+ return ret;
+}
+
+const gchar* __fake_g_dbus_method_invocation_get_sender(GDBusMethodInvocation *invocation)
+{
+ const gchar* ret = "fake";
+ return ret;
+}
+
+guint __fake_g_dbus_connection_signal_subscribe(GDBusConnection* con,
+ const gchar* sender, const gchar* interface_name, const gchar* member,
+ const gchar* object_path, const gchar* arg, GDBusSignalFlags flags,
+ GDBusSignalCallback cb, gpointer user_data, GDestroyNotify free_func)
+{
+ return 1;
+}
+
+gboolean __fake_g_dbus_interface_skeleton_export(GDBusInterfaceSkeleton* skel,
+ GDBusConnection* con, const gchar* path, GError** error)
+{
+ return true;
+}
+
+void __fake_g_variant_get(GVariant* value, const gchar* format_string, va_list v)
+{
+ gpointer ptr = va_arg(v, gpointer);
+ *(guint32 *) ptr = 1;
+}
+
+gboolean __fake_g_variant_iter_loop(GVariantIter* value, const gchar* format_string, va_list v)
+{
+ return false;
+}
+
+void __fake_g_variant_unref(GVariant* value)
+{
+}
+
+void __fake_g_variant_iter_free(GVariantIter* value)
+{
+}
+
+GVariant* __fake_g_variant_new(const gchar *string, va_list v)
+{
+ return nullptr;
+}
+
+gpointer __fake_g_hash_table_lookup(GHashTable* table, gconstpointer key)
+{
+ return nullptr;
+}
+
+guint __fake_g_hash_table_foreach_remove(GHashTable* table,
+ GHRFunc func, gpointer key)
+{
+ return 0;
+}
+
+gboolean __fake_g_hash_table_insert(GHashTable* table, gpointer key,
+ gpointer value)
+{
+ return true;
+}
+
+int __fake_cynara_initialize(cynara** c, const cynara_configuration* conf)
+{
+ return CYNARA_API_SUCCESS;
+}
+
+int __fake_cynara_creds_gdbus_get_user(GDBusConnection* c, const gchar* sender,
+ enum cynara_user_creds method, gchar** user)
+{
+ *user = nullptr;
+ return CYNARA_API_SUCCESS;
+}
+
+int __fake_cynara_creds_gdbus_get_client(GDBusConnection* c, const gchar* sender,
+ enum cynara_client_creds method, gchar** client)
+{
+ *client = nullptr;
+ return CYNARA_API_SUCCESS;
+}
+
+int __fake_cynara_check(cynara* c, const char* client, const char* session,
+ const char* user, const char* privilege)
+{
+ return CYNARA_API_ACCESS_ALLOWED;
+}
+char* __fake_cynara_session_from_pid(pid_t pid)
+{
+ return strdup("test");
+}
+
+class AlarmManagerTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ g_dbus_connection_call_sync_fake.custom_fake = __fake_g_dbus_connection_call_sync;
+ g_dbus_method_invocation_get_sender_fake.custom_fake = __fake_g_dbus_method_invocation_get_sender;
+ g_variant_get_fake.custom_fake = __fake_g_variant_get;
+ g_variant_iter_loop_fake.custom_fake = __fake_g_variant_iter_loop;
+ g_variant_unref_fake.custom_fake = __fake_g_variant_unref;
+ g_variant_iter_free_fake.custom_fake = __fake_g_variant_iter_free;
+ g_variant_new_fake.custom_fake = __fake_g_variant_new;
+ g_hash_table_lookup_fake.custom_fake = __fake_g_hash_table_lookup;
+ g_hash_table_foreach_remove_fake.custom_fake = __fake_g_hash_table_foreach_remove;
+ g_hash_table_insert_fake.custom_fake = __fake_g_hash_table_insert;
+
+ char fake[5] = "fake";
+ alarm_manager_alarm_create(nullptr, nullptr, fake, fake,
+ 2019, 9, 26, 13, 40, 20, 20, 2020, 9, 26, 1, 0, 0, 0, fake,
+ fake, nullptr);
+ }
+
+ void TearDown() override {
+ }
+
+ alarm_entry_t *alarm;
+};
+
+TEST_F(AlarmManagerTest, __get_proper_interval_p)
+{
+ long interval = 30;
+
+ __get_proper_interval(interval, ALARM_TYPE_INEXACT);
+}
+
+TEST_F(AlarmManagerTest, _alarm_initialize_p)
+{
+ g_dbus_connection_signal_subscribe_fake.custom_fake =
+ __fake_g_dbus_connection_signal_subscribe;
+ g_dbus_interface_skeleton_export_fake.custom_fake =
+ __fake_g_dbus_interface_skeleton_export;
+
+ _alarm_initialize();
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_create_p)
+{
+ gboolean ret;
+ char fake[5] = "fake";
+ ret = alarm_manager_alarm_create(nullptr, nullptr, fake, fake,
+ 2019, 9, 26, 13, 40, 20, 20, 2020, 9, 26, 1, 0, 0, 0, fake,
+ fake, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_create_periodic_p)
+{
+ gboolean ret;
+ char fake[5] = "fake";
+ ret = alarm_manager_alarm_create_periodic(nullptr, nullptr, fake,
+ fake, 10000, 0, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_create_appsvc_p)
+{
+ gboolean ret;
+ bundle *b;
+ bundle_raw *b_data = NULL;
+ int datalen = 0;
+ b = bundle_create();
+ bundle_add_str(b, "key", "val");
+ bundle_encode(b, &b_data, &datalen);
+
+ ret = alarm_manager_alarm_create_appsvc(nullptr, nullptr,
+ 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, (char*) b_data,
+ nullptr);
+ EXPECT_EQ(true, ret);
+
+ free(b_data);
+ bundle_free(b);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_create_noti_p)
+{
+ cynara_initialize_fake.custom_fake = __fake_cynara_initialize;
+ cynara_creds_gdbus_get_user_fake.custom_fake = __fake_cynara_creds_gdbus_get_user;
+ cynara_creds_gdbus_get_client_fake.custom_fake = __fake_cynara_creds_gdbus_get_client;
+ cynara_session_from_pid_fake.custom_fake = __fake_cynara_session_from_pid;
+ cynara_check_fake.custom_fake = __fake_cynara_check;
+
+ gboolean ret;
+ ret = alarm_manager_alarm_create_noti(nullptr, nullptr,
+ 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, nullptr, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_delete_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_delete(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_delete_all_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_delete_all(nullptr, nullptr, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_appsvc_info_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_appsvc_info(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_info_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_info(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_noti_info_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_noti_info(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_list_of_ids_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_list_of_ids(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_next_duetime_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_next_duetime(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_number_of_ids_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_number_of_ids(nullptr, nullptr, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_set_rtc_time_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_set_rtc_time(nullptr, nullptr, 2019, 9, 26, 13,
+ 40, 20, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_set_time_p)
+{
+ gboolean ret;
+ // ret = alarm_manager_alarm_set_time(nullptr, nullptr, 20, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_set_timezone_p)
+{
+ gboolean ret;
+ char zone[6] = "seoul";
+ ret = alarm_manager_alarm_set_timezone(nullptr, nullptr, zone, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_update_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_update(nullptr, nullptr, 1,
+ 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_all_info_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_all_info(nullptr, nullptr, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_set_time_with_propagation_delay_p)
+{
+ gboolean ret;
+// ret = alarm_manager_alarm_set_time_with_propagation_delay(nullptr, nullptr,
+// 20, 21, 30, 31, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_set_global_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_set_global(nullptr, nullptr, 1, true, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
+TEST_F(AlarmManagerTest, alarm_manager_alarm_get_global_p)
+{
+ gboolean ret;
+ ret = alarm_manager_alarm_get_global(nullptr, nullptr, 1, nullptr);
+ EXPECT_EQ(true, ret);
+}
+
* limitations under the License.
*/
+#ifndef MOCK_ALARM_DBUS_H_
+#define MOCK_ALARM_DBUS_H_
+
#include <glib.h>
#include "mock.h"
#include "alarm-mgr-stub.h"
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_info_sync,
- AlarmManager*, gint, gint*, gint*, gint*, gint*, gint*, gint*, gint*,
- gint*, gint*, gint*, gint*, gint*, gint*, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gint*, gint*, gint*, gint*, gint*, gint*, gint*,
+ gint*, gint*, gint*, gint*, gint*, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_create_appsvc_sync,
AlarmManager*, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint,
- gint, gint, gint, gint, const char*, gint*, gint*, GCancellable*, GError**);
+ gint, gint, gint, gint, const char*, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_appsvc_info_sync,
AlarmManager*, gint, gchar**, gint*, GCancellable*, GError**);
gint, gint, gint, const char*, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_noti_info_sync,
- AlarmManager*, gint, gchar**, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gchar**, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_set_rtc_time_sync,
- AlarmManager*, gint, gint, gint, gint, gint, gint, gint*, GCancellable*,
- GError**);
+ AlarmManager*, gint, gint, gint, gint, gint, gint, gint*, GCancellable*,
+ GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_delete_sync,
- AlarmManager*, gint, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_delete_all_sync,
- AlarmManager*, gint*, GCancellable*, GError**);
+ AlarmManager*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_number_of_ids_sync,
- AlarmManager*, gint*, gint*, GCancellable*, GError**);
+ AlarmManager*, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_list_of_ids_sync,
- AlarmManager*, gint, GVariant**, gint*, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, GVariant**, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_next_duetime_sync,
- AlarmManager*, gint, gint*, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gint*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_create_periodic_sync,
- AlarmManager*, const gchar*, const gchar*, gint, gint, gint, gint*,
- gint*, GCancellable*, GError**);
+ AlarmManager*, const gchar*, const gchar*, gint, gint, gint, gint*,
+ gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_set_time_sync,
- AlarmManager*, gint, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gint*, GCancellable*, GError**);
DECLARE_FAKE_VOID_FUNC(alarm_manager_call_alarm_set_time, AlarmManager*, gint,
- GCancellable*, GAsyncReadyCallback, gpointer);
+ GCancellable*, GAsyncReadyCallback, gpointer);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_set_timezone_sync,
- AlarmManager*, const char*, gint*, GCancellable*, GError**);
+ AlarmManager*, const char*, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean,
- alarm_manager_call_alarm_set_time_with_propagation_delay_sync,
- AlarmManager*, guint, guint, guint, guint, gint*, GCancellable*,
- GError**);
+ alarm_manager_call_alarm_set_time_with_propagation_delay_sync,
+ AlarmManager*, guint, guint, guint, guint, gint*, GCancellable*,
+ GError**);
DECLARE_FAKE_VOID_FUNC(alarm_manager_call_alarm_set_time_with_propagation_delay,
- AlarmManager*, guint, guint, guint, guint, GCancellable*,
- GAsyncReadyCallback, gpointer);
+ AlarmManager*, guint, guint, guint, guint, GCancellable*,
+ GAsyncReadyCallback, gpointer);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_update_sync,
- AlarmManager*, gint, gint, gint, gint, gint, gint, gint, gint, gint,
- gint, gint, gint, gint, gint, gint, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gint, gint, gint, gint, gint, gint, gint, gint,
+ gint, gint, gint, gint, gint, gint, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_set_global_sync,
- AlarmManager*, gint, gboolean, gint*, GCancellable*, GError**);
+ AlarmManager*, gint, gboolean, gint*, GCancellable*, GError**);
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_global_sync,
- AlarmManager*, gint, gboolean*, gint*, GCancellable*, GError**);
-
-//glib
-DECLARE_FAKE_VALUE_FUNC(GVariant*, g_dbus_connection_call_sync, GDBusConnection*,
- const gchar*, const gchar*, const gchar*, const gchar*, GVariant*,
- const GVariantType*, GDBusCallFlags, gint, GCancellable*, GError**);
-
-DECLARE_FAKE_VALUE_FUNC(const gchar*, g_dbus_method_invocation_get_sender, GDBusMethodInvocation*);
-
-DECLARE_FAKE_VOID_FUNC3_VARARG(g_variant_get, GVariant*, const gchar*, ...);
-DECLARE_FAKE_VALUE_FUNC3_VARARG(gboolean, g_variant_iter_loop, GVariantIter*, const gchar*, ...);
-DECLARE_FAKE_VOID_FUNC(g_variant_iter_free, GVariantIter*);
-DECLARE_FAKE_VOID_FUNC(g_variant_unref, GVariant*);
-
+ AlarmManager*, gint, gboolean*, gint*, GCancellable*, GError**);
+#endif //MOCK_ALARM_DBUS_H_
--- /dev/null
+/*
+ * Copyright (c) 2019 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 MOCK_CYNARA_H_
+#define MOCK_CYNARA_H_
+
+#include <cynara-session.h>
+#include <cynara-client.h>
+#include <cynara-creds-gdbus.h>
+
+#include "mock.h"
+
+DECLARE_FAKE_VALUE_FUNC(int, cynara_initialize, cynara**,
+ const cynara_configuration*);
+DECLARE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*,
+ const gchar*, enum cynara_user_creds, gchar **);
+DECLARE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_client, GDBusConnection*,
+ const gchar*, enum cynara_client_creds, gchar **);
+DECLARE_FAKE_VALUE_FUNC(char*, cynara_session_from_pid, pid_t);
+DECLARE_FAKE_VALUE_FUNC(int, cynara_check, cynara*, const char*, const char*,
+ const char*, const char*);
+
+
+#endif //MOCK_CYNARA_H_
+++ /dev/null
-/*\r
- * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-#include "mock.h"\r
-\r
-#include <glib.h>\r
-#include <gio/gio.h>\r
-\r
-DECLARE_FAKE_VALUE_FUNC(GDBusConnection*, g_bus_get_sync,\r
- GBusType, GCancellable*, GError**);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(GDBusProxy*, g_dbus_proxy_new_sync,\r
- GDBusConnection*, GDBusProxyFlags, GDBusInterfaceInfo*,\r
- const gchar*, const gchar*, const gchar*, GCancellable*, GError**);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(GDBusNodeInfo*, g_dbus_node_info_new_for_xml,\r
- const gchar*, GError**);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(guint, g_bus_own_name_on_connection, GDBusConnection*,\r
- const gchar*, GBusNameOwnerFlags,GBusNameAcquiredCallback,\r
- GBusNameLostCallback, gpointer, GDestroyNotify);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(guint, g_dbus_connection_register_object,\r
- GDBusConnection*, const gchar*, GDBusInterfaceInfo*,\r
- const GDBusInterfaceVTable*, gpointer, GDestroyNotify, GError**);\r
-\r
-DECLARE_FAKE_VOID_FUNC(g_dbus_method_invocation_return_value,\r
- GDBusMethodInvocation*, GVariant*);\r
-\r
-DECLARE_FAKE_VOID_FUNC(g_bus_unown_name, guint);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_emit_signal,\r
- GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,\r
- GVariant*, GError**);\r
-\r
-DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_flush_sync,\r
- GDBusConnection*, GCancellable*, GError**);\r
-\r
-DECLARE_FAKE_VOID_FUNC(g_dbus_node_info_unref, GDBusNodeInfo*);\r
--- /dev/null
+/*
+ * Copyright (c) 2019 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 MOCK_GIO_H_
+#define MOCK_GIO_H_
+
+#include "mock.h"
+
+#include <glib.h>
+#include <gio/gio.h>
+
+DECLARE_FAKE_VALUE_FUNC(GDBusConnection*, g_bus_get_sync,
+ GBusType, GCancellable*, GError**);
+
+DECLARE_FAKE_VALUE_FUNC(GDBusProxy*, g_dbus_proxy_new_sync,
+ GDBusConnection*, GDBusProxyFlags, GDBusInterfaceInfo*,
+ const gchar*, const gchar*, const gchar*, GCancellable*, GError**);
+
+DECLARE_FAKE_VALUE_FUNC(GDBusNodeInfo*, g_dbus_node_info_new_for_xml,
+ const gchar*, GError**);
+
+DECLARE_FAKE_VALUE_FUNC(guint, g_bus_own_name_on_connection, GDBusConnection*,
+ const gchar*, GBusNameOwnerFlags,GBusNameAcquiredCallback,
+ GBusNameLostCallback, gpointer, GDestroyNotify);
+
+DECLARE_FAKE_VALUE_FUNC(guint, g_dbus_connection_register_object,
+ GDBusConnection*, const gchar*, GDBusInterfaceInfo*,
+ const GDBusInterfaceVTable*, gpointer, GDestroyNotify, GError**);
+
+DECLARE_FAKE_VOID_FUNC(g_dbus_method_invocation_return_value,
+ GDBusMethodInvocation*, GVariant*);
+
+DECLARE_FAKE_VALUE_FUNC(GVariant*, g_dbus_connection_call_sync, GDBusConnection*,
+ const gchar*, const gchar*, const gchar*, const gchar*, GVariant*,
+ const GVariantType*, GDBusCallFlags, gint, GCancellable*, GError**);
+
+DECLARE_FAKE_VALUE_FUNC(const gchar*, g_dbus_method_invocation_get_sender,
+ GDBusMethodInvocation*);
+
+DECLARE_FAKE_VOID_FUNC(g_bus_unown_name, guint);
+
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_emit_signal,
+ GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,
+ GVariant*, GError**);
+
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_flush_sync,
+ GDBusConnection*, GCancellable*, GError**);
+
+DECLARE_FAKE_VOID_FUNC(g_dbus_node_info_unref, GDBusNodeInfo*);
+
+DECLARE_FAKE_VALUE_FUNC(guint, g_dbus_connection_signal_subscribe,
+ GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,
+ const gchar*, GDBusSignalFlags, GDBusSignalCallback, gpointer,
+ GDestroyNotify);
+
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_dbus_interface_skeleton_export,
+ GDBusInterfaceSkeleton*, GDBusConnection*, const gchar*, GError**);
+
+#endif //MOCK_GIO_H_
--- /dev/null
+/*
+ * Copyright (c) 2019 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 MOCK_GLIB_H_
+#define MOCK_GLIB_H_
+
+#include <glib.h>
+
+#include "mock.h"
+
+DECLARE_FAKE_VOID_FUNC3_VARARG(g_variant_get, GVariant*, const gchar*, ...);
+DECLARE_FAKE_VALUE_FUNC3_VARARG(gboolean, g_variant_iter_loop, GVariantIter*,
+ const gchar*, ...);
+DECLARE_FAKE_VOID_FUNC(g_variant_iter_free, GVariantIter*);
+DECLARE_FAKE_VOID_FUNC(g_variant_unref, GVariant*);
+DECLARE_FAKE_VALUE_FUNC2_VARARG(GVariant*, g_variant_new, const gchar*, ...);
+DECLARE_FAKE_VALUE_FUNC(gpointer, g_hash_table_lookup, GHashTable*, gconstpointer);
+DECLARE_FAKE_VALUE_FUNC(guint, g_hash_table_foreach_remove, GHashTable*,
+ GHRFunc, gpointer);
+DECLARE_FAKE_VALUE_FUNC(gboolean, g_hash_table_insert, GHashTable*,
+ gpointer, gpointer);
+
+#endif //MOCK_GLIB_H_
* limitations under the License.
*/
-#include "gio.h"
-#include "mock.h"
#include "alarm_dbus.h"
#include "aul_fake.h"
+#include "cynara_fake.h"
+#include "gio_fake.h"
+#include "glib_fake.h"
+#include "mock.h"
#include "notification_fake.h"
DEFINE_FFF_GLOBALS;
GVariant*, GError**);
DEFINE_FAKE_VALUE_FUNC(gboolean, g_dbus_connection_flush_sync,
GDBusConnection*, GCancellable*, GError**);
-
DEFINE_FAKE_VOID_FUNC(g_dbus_node_info_unref, GDBusNodeInfo*);
-
+DEFINE_FAKE_VALUE_FUNC(guint, g_dbus_connection_signal_subscribe,
+ GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*,
+ const gchar*, GDBusSignalFlags, GDBusSignalCallback, gpointer,
+ GDestroyNotify);
+DEFINE_FAKE_VALUE_FUNC(gboolean, g_dbus_interface_skeleton_export,
+ GDBusInterfaceSkeleton*, GDBusConnection*, const gchar*, GError**);
/* alarm_dbus.h */
DEFINE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_info_sync,
DEFINE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_update_sync, AlarmManager*, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint, gint*, GCancellable*, GError**);
DEFINE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_set_global_sync, AlarmManager*, gint, gboolean, gint*, GCancellable*, GError**);
DEFINE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_global_sync, AlarmManager*, gint, gboolean*, gint*, GCancellable*, GError**);
+
+/* glib_fake.h */
DEFINE_FAKE_VALUE_FUNC(GVariant*, g_dbus_connection_call_sync, GDBusConnection*,
const gchar*, const gchar*, const gchar*, const gchar*, GVariant*,
const GVariantType*, GDBusCallFlags, gint, GCancellable*, GError**);
DEFINE_FAKE_VALUE_FUNC3_VARARG(gboolean, g_variant_iter_loop, GVariantIter*, const gchar*, ...);
DEFINE_FAKE_VOID_FUNC(g_variant_iter_free, GVariantIter*);
DEFINE_FAKE_VOID_FUNC(g_variant_unref, GVariant*);
+DEFINE_FAKE_VALUE_FUNC2_VARARG(GVariant*, g_variant_new, const gchar*, ...);
+DEFINE_FAKE_VALUE_FUNC(gpointer, g_hash_table_lookup, GHashTable*, gconstpointer);
+DEFINE_FAKE_VALUE_FUNC(guint, g_hash_table_foreach_remove, GHashTable*,
+ GHRFunc, gpointer);
+DEFINE_FAKE_VALUE_FUNC(gboolean, g_hash_table_insert, GHashTable*,
+ gpointer, gpointer);
/* aul.h */
DEFINE_FAKE_VALUE_FUNC(int, aul_app_get_appid_bypid, int, char*, int);
/* notification.h */
DEFINE_FAKE_VALUE_FUNC(notification_h, notification_create, notification_type_e);
DEFINE_FAKE_VALUE_FUNC(GVariant*, notification_ipc_make_gvariant_from_noti, notification_h, bool);
+
+/* cynara_fake.h */
+DEFINE_FAKE_VALUE_FUNC(int, cynara_initialize, cynara**,
+ const cynara_configuration*);
+DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*,
+ const gchar*, enum cynara_user_creds, gchar **);
+DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_client, GDBusConnection*,
+ const gchar*, enum cynara_client_creds, gchar **);
+DEFINE_FAKE_VALUE_FUNC(char*, cynara_session_from_pid, pid_t);
+DEFINE_FAKE_VALUE_FUNC(int, cynara_check, cynara*, const char*, const char*,
+ const char*, const char*);
+
-/*\r
- * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-#ifndef MOCK_NOTIFICATION_H_\r
-#define MOCK_NOTIFICATION_H_\r
-\r
-#include <glib.h>\r
-#include <notification.h>\r
-#include <notification_ipc.h>\r
-\r
-#include "mock.h"\r
-\r
-DECLARE_FAKE_VALUE_FUNC(notification_h, notification_create, notification_type_e);\r
-DECLARE_FAKE_VALUE_FUNC(GVariant*, notification_ipc_make_gvariant_from_noti, notification_h, bool);\r
-\r
-#endif //MOCK_NOTIFICATION_H_\r
+/*
+ * Copyright (c) 2019 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 MOCK_NOTIFICATION_H_
+#define MOCK_NOTIFICATION_H_
+
+#include <glib.h>
+#include <notification.h>
+#include <notification_ipc.h>
+
+#include "mock.h"
+
+DECLARE_FAKE_VALUE_FUNC(notification_h, notification_create, notification_type_e);
+DECLARE_FAKE_VALUE_FUNC(GVariant*, notification_ipc_make_gvariant_from_noti,
+ notification_h, bool);
+
+#endif //MOCK_NOTIFICATION_H_
projects / platform / core / appfw / alarm-manager.git / commitdiff