%endif
%check
-export LD_LIBRARY_PATH=./src/
-LD_PRELOAD=./tests/unittest/libwifi-aware-mock.so ./tests/unittest/wifi-aware-unittest
+export LD_LIBRARY_PATH=./src/:./tests/unittest/mocks/
+LD_PRELOAD=./tests/unittest/mocks/libwifi-aware-mock.so ./tests/unittest/wifi-aware-unittest
%if 0%{?gcov:1}
lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info
GVariant *parameters, gpointer user_data)
{
__WIFI_AWARE_FUNC_ENTER__;
- WIFI_AWARE_LOGD("NAN Service is discovered");
+ WIFI_AWARE_LOGD("Followup message is received");
uint16_t pub_sub_id = 0;
unsigned int peer_id = 0;
#
SET(WIFI_AWARE_MOCK "wifi-aware-mock")
-SET(WIFI_AWARE_MOCK_SRCS
- mocks/wifi-aware-mock.c
- mocks/wifi-aware-mock-gdbus-internal.c)
-
-INCLUDE_DIRECTORIES(
- ${CMAKE_SOURCE_DIR}/include
- ${CMAKE_SOURCE_DIR}/src/include
- ${CMAKE_CURRENT_SOURCE_DIR}/mocks
- )
-ADD_DEFINITIONS("-fvisibility=default")
-ADD_LIBRARY(${WIFI_AWARE_MOCK} SHARED ${WIFI_AWARE_MOCK_SRCS})
+SET(TARGET_WIFI_AWARE_MOCK_INTERFACE "wifi-aware-mock-interface")
+ADD_SUBDIRECTORY(mocks)
SET(WIFI_AWARE_UNITTEST "wifi-aware-unittest")
-
pkg_check_modules(TARGET_WIFI_AWARE_UNITTEST REQUIRED
capi-system-info
glib-2.0
)
INCLUDE_DIRECTORIES(
${TARGET_WIFI_AWARE_UNITTEST_INCLUDE_DIRS}
+ ${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_CURRENT_SOURCE_DIR}/mocks
)
LINK_DIRECTORIES(${TARGET_WIFI_AWARE_UNITTEST_LIBRARY_DIRS})
ADD_EXECUTABLE(${WIFI_AWARE_UNITTEST} ${UNITTEST_SRCS})
TARGET_LINK_LIBRARIES(${WIFI_AWARE_UNITTEST}
${TARGET_WIFI_AWARE}
+ ${TARGET_WIFI_AWARE_MOCK_INTERFACE}
${TARGET_WIFI_AWARE_UNITTEST_LIBRARIES}
)
--- /dev/null
+# Copyright (c) 2020 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.
+#
+# @file CMakeLists.txt
+#
+
+SET(WIFI_AWARE_MOCK_SRCS
+ wifi-aware-mock.c
+ wifi-aware-mock-gdbus-internal.c)
+
+INCLUDE_DIRECTORIES(
+ ${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/src/include
+ )
+ADD_DEFINITIONS("-fvisibility=default")
+ADD_LIBRARY(${WIFI_AWARE_MOCK} SHARED ${WIFI_AWARE_MOCK_SRCS})
+
+
+SET(TARGET_WIFI_AWARE_MOCK_INTERFACE_SRCS
+ wifi-aware-mock-interface.c)
+ADD_LIBRARY(${TARGET_WIFI_AWARE_MOCK_INTERFACE} SHARED ${TARGET_WIFI_AWARE_MOCK_INTERFACE_SRCS})
gpointer user_data;
} gdbus_result_data_s;
+typedef struct {
+ GDBusSignalCallback callback;
+ gchar signal_name[50];
+ GVariant *parameters;
+ gpointer user_data;
+} gdbus_signal_data_s;
+
static gdbus_result_data_s _gdbus_async_result;
+static gdbus_signal_data_s _signal_data;
static gboolean __reply_async_method(gpointer data)
{
struct {
const gchar *interface_name;
const gchar *method_name;
- // parameters is omitted
void(*async_handler)(GVariant *parameters, GAsyncReadyCallback callback, gpointer user_data);
GVariant *(*sync_handler)(GVariant *parameters);
-} wifi_aware_g_dbus_method_list[] = {
+} wifi_aware_gdbus_method_list[] = {
{
"net.nan.discovery",
"Enable",
return (GDBusConnection *)g_object_new(G_TYPE_DBUS_CONNECTION, NULL);
}
-bool _check_g_dbus_bus_name(const gchar *bus_name)
+bool _check_gdbus_bus_name(const gchar *bus_name)
{
return g_strcmp0(bus_name, WIFI_AWARE_INTERFACE) == 0;
}
-bool _check_g_dbus_object_path(const gchar *object_path)
+bool _check_gdbus_object_path(const gchar *object_path)
{
return g_strcmp0(object_path, WIFI_AWARE_DISCOVERY_PATH) == 0;
}
-bool _check_g_dbus_interface_name(const gchar *interface_name)
+bool _check_gdbus_interface_name(const gchar *interface_name)
{
return g_strcmp0(interface_name, WIFI_AWARE_DISCOVERY_INTERFACE) == 0;
}
static bool __is_same_method(int i, const char *interface_name, const char *method_name)
{
- return (g_strcmp0(wifi_aware_g_dbus_method_list[i].interface_name, interface_name) == 0
- && g_strcmp0(wifi_aware_g_dbus_method_list[i].method_name, method_name) == 0);
+ return (g_strcmp0(wifi_aware_gdbus_method_list[i].interface_name, interface_name) == 0
+ && g_strcmp0(wifi_aware_gdbus_method_list[i].method_name, method_name) == 0);
}
void _handle_async_method(const gchar *interface_name,
GAsyncReadyCallback callback, gpointer user_data)
{
for (int i = 0; ; ++i) {
- if (wifi_aware_g_dbus_method_list[i].interface_name == NULL)
+ if (wifi_aware_gdbus_method_list[i].interface_name == NULL)
return;
if (__is_same_method(i, interface_name, method_name))
- wifi_aware_g_dbus_method_list[i].async_handler(parameters, callback, user_data);
+ wifi_aware_gdbus_method_list[i].async_handler(parameters, callback, user_data);
}
}
const char *method_name, GVariant *parameters, GError **error)
{
for (int i = 0; ; ++i) {
- if (wifi_aware_g_dbus_method_list[i].interface_name == NULL) {
+ if (wifi_aware_gdbus_method_list[i].interface_name == NULL) {
_set_gdbus_error(G_DBUS_ERROR_UNKNOWN_METHOD, "UnknownMethod", error);
return NULL;
}
if (__is_same_method(i, interface_name, method_name))
- return wifi_aware_g_dbus_method_list[i].sync_handler(parameters);
+ return wifi_aware_gdbus_method_list[i].sync_handler(parameters);
}
}
+static GVariant *__pack_byte_array(const unsigned char *array, uint16_t len)
+{
+ GVariantBuilder *builder = NULL;
+ GVariant *var = NULL;
+
+ if (array == NULL)
+ return NULL;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+
+ for (int i = 0; i < len; ++i)
+ g_variant_builder_add(builder, "y", array[i]);
+
+ var = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
+ return var;
+}
+
+static void __service_discovered(GDBusSignalCallback callback, gpointer user_data)
+{
+ if (!callback)
+ return;
+
+ unsigned char mac[MAC_ADDR_LEN] = {0, 0, 0, 0, 0, 0};
+ unsigned char specific_info[5] = {'1', '2', '3', '4', '5'};
+ _signal_data.callback = callback;
+ strncpy(_signal_data.signal_name, "ServiceDiscovered", 50);
+ _signal_data.parameters = g_variant_new("(quvqvi)",
+ DUMMY_SUBSCRIBE_ID, DUMMY_PEER_ID, __pack_byte_array(mac, MAC_ADDR_LEN),
+ 5, __pack_byte_array(specific_info, 5), DUMMY_DISTANCE);
+ _signal_data.user_data = user_data;
+}
+
+static void __message_received(GDBusSignalCallback callback, gpointer user_data)
+{
+ if (!callback)
+ return;
+
+ unsigned char mac[MAC_ADDR_LEN] = {0, 0, 0, 0, 0, 0};
+ unsigned char message[5] = {'1', '2', '3', '4', '5'};
+ _signal_data.callback = callback;
+ strncpy(_signal_data.signal_name, "MessageReceived", 50);
+ _signal_data.parameters = g_variant_new("(quvqv)",
+ DUMMY_SUBSCRIBE_ID, DUMMY_PEER_ID, __pack_byte_array(mac, MAC_ADDR_LEN),
+ 5, __pack_byte_array(message, 5));
+ _signal_data.user_data = user_data;
+}
+
+struct {
+ const gchar *interface_name;
+ const gchar *signal_name;
+ void(*subscribe)(GDBusSignalCallback callback, gpointer user_data);
+} wifi_aware_gdbus_signal_list[] = {
+ [SERVICE_DISCOVERED] = {
+ "net.nan.discovery",
+ "ServiceDiscovered",
+ __service_discovered,
+ },
+ [MESSAGE_RECEIVED] = {
+ "net.nan.discovery",
+ "MessageReceived",
+ __message_received,
+ },
+ {
+ NULL,
+ NULL,
+ NULL,
+ },
+};
+
+static gboolean __emit_signal(gpointer data)
+{
+ gdbus_signal_data_s *signal_data = (gdbus_signal_data_s *)data;
+ signal_data->callback(_get_dummy_gdbus_connection(),
+ NULL, WIFI_AWARE_INTERFACE,
+ WIFI_AWARE_DISCOVERY_INTERFACE, signal_data->signal_name,
+ signal_data->parameters, signal_data->user_data);
+ return FALSE;
+}
+
+void _emit_gdbus_signal(wifi_aware_gdbus_signal_e signal)
+{
+ if (g_strcmp0(_signal_data.signal_name,
+ wifi_aware_gdbus_signal_list[(int)signal].signal_name) != 0)
+ return;
+
+ g_timeout_add(SIGNAL_DELAY, __emit_signal, &_signal_data);
+}
+
+static bool __is_same_signal(int i, const char *interface_name, const char *signal_name)
+{
+ return (g_strcmp0(wifi_aware_gdbus_signal_list[i].interface_name, interface_name) == 0
+ && g_strcmp0(wifi_aware_gdbus_signal_list[i].signal_name, signal_name) == 0);
+}
+
guint _signal_subscribe(const char *interface_name,
const char *member,
GDBusSignalCallback callback, gpointer user_data)
{
+ for (int i = 0; ; ++i) {
+ if (wifi_aware_gdbus_signal_list[i].interface_name == NULL)
+ break;
+ if (__is_same_signal(i, interface_name, member))
+ wifi_aware_gdbus_signal_list[i].subscribe(callback, user_data);
+ }
return DUMMY_SIGNAL_ID;
}
#include "wifi-aware-gdbus.h"
-#define ASYNC_RESULT_DELAY 500
+#define ASYNC_RESULT_DELAY 10
+#define SIGNAL_DELAY 10
#define DUMMY_CLIENT_ID 1
#define DUMMY_SIGNAL_ID 1
#define DUMMY_PUBLISH_ID 1
#define DUMMY_SUBSCRIBE_ID 1
+#define DUMMY_PEER_ID 1
+#define DUMMY_DISTANCE 1
+#define MAC_ADDR_LEN 6
+
+typedef enum {
+ SERVICE_DISCOVERED = 0,
+ MESSAGE_RECEIVED,
+} wifi_aware_gdbus_signal_e;
GDBusConnection *_get_dummy_gdbus_connection();
-bool _check_g_dbus_bus_name(const gchar *bus_name);
-bool _check_g_dbus_object_path(const gchar *object_path);
-bool _check_g_dbus_interface_name(const gchar *interface_name);
+bool _check_gdbus_bus_name(const gchar *bus_name);
+bool _check_gdbus_object_path(const gchar *object_path);
+bool _check_gdbus_interface_name(const gchar *interface_name);
void _handle_async_method(const gchar *interface_name,
const char *method_name, GVariant *parameters,
GAsyncReadyCallback callback, gpointer user_data);
void _set_gdbus_error(gint code, const char *message, GError **error);
GVariant *_handle_sync_method(const gchar *interface_name,
const char *method_name, GVariant *parameters, GError **error);
+void _emit_gdbus_signal(wifi_aware_gdbus_signal_e signal);
guint _signal_subscribe(const char *interface_name,
const char *member,
GDBusSignalCallback callback, gpointer user_data);
--- /dev/null
+/*
+ * Copyright (c) 2020 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 <stdio.h>
+
+#include "wifi-aware-mock-interface.h"
+
+void wifi_aware_mock_emit_gdbus_signal(wifi_aware_gdbus_signal_e signal)
+{
+}
--- /dev/null
+/*
+ * Copyright (c) 2020 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef enum {
+ SERVICE_DISCOVERED = 0,
+ MESSAGE_RECEIVED,
+} wifi_aware_gdbus_signal_e;
+
+void wifi_aware_mock_emit_gdbus_signal(wifi_aware_gdbus_signal_e signal);
+#ifdef __cplusplus
+}
+#endif
* limitations under the License.
*/
+#include <stdio.h>
#include <stdbool.h>
#include <stddef.h>
#include <system_info.h>
GAsyncReadyCallback callback,
gpointer user_data)
{
- if (!_check_g_dbus_bus_name(bus_name))
+ if (!_check_gdbus_bus_name(bus_name))
return;
- if (!_check_g_dbus_object_path(object_path))
+ if (!_check_gdbus_object_path(object_path))
return;
- if (!_check_g_dbus_interface_name(interface_name))
+ if (!_check_gdbus_interface_name(interface_name))
return;
_handle_async_method(interface_name, method_name, parameters, callback, user_data);
}
GCancellable *cancellable,
GError **error)
{
- if (!_check_g_dbus_bus_name(bus_name)) {
+ if (!_check_gdbus_bus_name(bus_name)) {
_set_gdbus_error(G_DBUS_ERROR_UNKNOWN_METHOD, "UnknownMethod", error);
return NULL;
}
- if (!_check_g_dbus_object_path(object_path)) {
+ if (!_check_gdbus_object_path(object_path)) {
_set_gdbus_error(G_DBUS_ERROR_UNKNOWN_METHOD, "UnknownMethod", error);
return NULL;
}
- if (!_check_g_dbus_interface_name(interface_name)) {
+ if (!_check_gdbus_interface_name(interface_name)) {
_set_gdbus_error(G_DBUS_ERROR_UNKNOWN_METHOD, "UnknownMethod", error);
return NULL;
}
guint subscription_id)
{
}
+
+void wifi_aware_mock_emit_gdbus_signal(wifi_aware_gdbus_signal_e signal)
+{
+ _emit_gdbus_signal(signal);
+}
{
g_published = false;
g_subscribed = false;
+ g_discovered = false;
+ g_message_received = false;
WifiAware::SetUp();
wifi_aware_enable(WifiAware::__enabled_cb, NULL);
RUN_GMAIN_LOOP;
static bool g_published;
static bool g_subscribed;
+ static bool g_discovered;
+ static bool g_message_received;
};
#include "wifi-aware-session-unittest-fixture.h"
#include "wifi-aware.h"
+extern "C" {
+#include "wifi-aware-mock-interface.h"
+}
+
bool WifiAwareSession::g_published;
bool WifiAwareSession::g_subscribed;
+bool WifiAwareSession::g_discovered;
+bool WifiAwareSession::g_message_received;
void WifiAwareSession::__published_cb(wifi_aware_session_h session, wifi_aware_error_e error, void *user_data)
{
const unsigned char *service_specific_info, size_t service_specific_info_len,
int distance, void *user_data)
{
+ g_discovered = true;
+ QUIT_GMAIN_LOOP;
}
void WifiAwareSession::__send_reply(wifi_aware_session_h session,
void WifiAwareSession::__received_cb(wifi_aware_session_h session, wifi_aware_peer_h peer,
const unsigned char *message, size_t len, void *user_data)
{
+ g_message_received = true;
+ QUIT_GMAIN_LOOP;
}
TEST_F(WifiAwareSession, wifi_aware_session_create_p1)
wifi_aware_session_destroy(session);
}
+// wifi_aware_service_discovered_cb is called
+TEST_F(WifiAwareSession, wifi_aware_service_discovered_cb_p)
+{
+ wifi_aware_subscribe_h subscribe_config;
+ wifi_aware_session_h session;
+
+ wifi_aware_subscribe_create(&subscribe_config);
+ wifi_aware_subscribe_set_service_name(subscribe_config, SERVICE_NAME);
+ wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session);
+
+ wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL);
+ wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+ RUN_GMAIN_LOOP;
+
+ wifi_aware_mock_emit_gdbus_signal(SERVICE_DISCOVERED);
+ RUN_GMAIN_LOOP;
+
+ CHECK_RESULT(g_discovered, true, "service_discovered_cb");
+
+ wifi_aware_session_stop(session);
+ wifi_aware_session_destroy(session);
+ wifi_aware_subscribe_destroy(subscribe_config);
+}
+
+// wifi_aware_service_discovered_cb is not called
+TEST_F(WifiAwareSession, wifi_aware_service_discovered_cb_n)
+{
+ wifi_aware_subscribe_h subscribe_config;
+ wifi_aware_session_h session;
+
+ wifi_aware_subscribe_create(&subscribe_config);
+ wifi_aware_subscribe_set_service_name(subscribe_config, SERVICE_NAME);
+ wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session);
+
+ wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL);
+ wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+ RUN_GMAIN_LOOP;
+
+ RUN_GMAIN_LOOP;
+
+ CHECK_RESULT(g_discovered, false, "service_discovered_cb");
+
+ wifi_aware_session_stop(session);
+ wifi_aware_session_destroy(session);
+ wifi_aware_subscribe_destroy(subscribe_config);
+}
+
TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_n1)
{
int ret = 0;
CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_unset_message_received_cb");
}
+TEST_F(WifiAwareSession, wifi_aware_message_received_cb_p)
+{
+ wifi_aware_publish_h publish_config;
+ wifi_aware_session_h session;
+
+ wifi_aware_publish_create(&publish_config);
+ wifi_aware_publish_set_service_name(publish_config, SERVICE_NAME);
+ wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session);
+
+ wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL);
+ wifi_aware_session_publish(session, publish_config, WifiAwareSession::__published_cb, NULL);
+ RUN_GMAIN_LOOP;
+
+ wifi_aware_mock_emit_gdbus_signal(MESSAGE_RECEIVED);
+ RUN_GMAIN_LOOP;
+
+ CHECK_RESULT(g_message_received, true, "message_received_cb");
+
+ wifi_aware_session_stop(session);
+ wifi_aware_session_destroy(session);
+ wifi_aware_publish_destroy(publish_config);
+}
+
+TEST_F(WifiAwareSession, wifi_aware_message_received_cb_n)
+{
+ wifi_aware_publish_h publish_config;
+ wifi_aware_session_h session;
+
+ wifi_aware_publish_create(&publish_config);
+ wifi_aware_publish_set_service_name(publish_config, SERVICE_NAME);
+ wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session);
+
+ wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL);
+ wifi_aware_session_publish(session, publish_config, WifiAwareSession::__published_cb, NULL);
+ RUN_GMAIN_LOOP;
+
+ RUN_GMAIN_LOOP;
+
+ CHECK_RESULT(g_message_received, false, "message_received_cb");
+
+ wifi_aware_session_stop(session);
+ wifi_aware_session_destroy(session);
+ wifi_aware_publish_destroy(publish_config);
+}
ASSERT_EQ(ret, expected) << "FAIL " << message; \
} while (0)
-#define CALLBACK_TIMEOUT 20000
+#define CALLBACK_TIMEOUT 50
#define RUN_GMAIN_LOOP do { \
WifiAware::g_main_loop = g_main_loop_new(NULL, false); \
WifiAware::g_timeout_id = g_timeout_add(CALLBACK_TIMEOUT, \
WifiAware::_wifi_aware_callback_timeout, WifiAware::g_main_loop); \
g_main_loop_run(WifiAware::g_main_loop); \
- g_source_remove(WifiAware::g_timeout_id); \
+ if (WifiAware::g_timeout_id > 0) \
+ g_source_remove(WifiAware::g_timeout_id); \
WifiAware::g_main_loop = NULL; \
} while (0)
{
GMainLoop *main_loop = NULL;
main_loop = (GMainLoop *)data;
- if (main_loop != NULL)
- {
- g_main_loop_quit(main_loop);
- }
- return false;
+ if (main_loop != NULL)
+ {
+ g_main_loop_quit(main_loop);
+ WifiAware::g_timeout_id = 0;
+ }
+ return FALSE;
}
void WifiAware::__enabled_cb(wifi_aware_error_e error, void *user_data)
projects / platform / core / api / wifi-aware.git / commitdiff