From: Cheoleun Moon Date: Tue, 16 Jun 2020 02:47:22 +0000 (+0900) Subject: Add unittests for wifi_aware_session X-Git-Tag: submit/tizen/20200616.063112~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6055a1605b7dcc49d37eafce89f422fc30e91f3f;p=platform%2Fcore%2Fapi%2Fwifi-aware.git Add unittests for wifi_aware_session - Add mocks for g_dbus_connection_signal_subscribe and g_dbus_connection_signal_subscribe Change-Id: Ie7b65dc3444333f0c2ff50446efb1834f63e1976 --- diff --git a/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.c b/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.c index 5a1e1ff..37a6810 100644 --- a/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.c +++ b/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.c @@ -46,8 +46,49 @@ static void __enable_handler(GVariant *parameters, GAsyncReadyCallback callback, static GVariant *__disable_handler(GVariant *parameters) { - GVariant *reply = g_variant_new("(i)", WIFI_AWARE_ERROR_NONE); - return reply; + return g_variant_new("(i)", WIFI_AWARE_ERROR_NONE); +} + +static void __publish_handler(GVariant *parameters, GAsyncReadyCallback callback, gpointer user_data) +{ + _gdbus_async_result.callback = callback; + _gdbus_async_result.result = g_variant_new("(qi)", DUMMY_PUBLISH_ID, WIFI_AWARE_ERROR_NONE); + _gdbus_async_result.user_data = user_data; + g_timeout_add(ASYNC_RESULT_DELAY, __reply_async_method, &_gdbus_async_result); +} + +static void __update_publish_handler(GVariant *parameters, GAsyncReadyCallback callback, gpointer user_data) +{ + _gdbus_async_result.callback = callback; + _gdbus_async_result.result = g_variant_new("(qi)", DUMMY_PUBLISH_ID, WIFI_AWARE_ERROR_NONE); + _gdbus_async_result.user_data = user_data; + g_timeout_add(ASYNC_RESULT_DELAY, __reply_async_method, &_gdbus_async_result); +} + +static GVariant *__cancel_publish_handler(GVariant *parameters) +{ + return g_variant_new("(i)", WIFI_AWARE_ERROR_NONE); +} + +static void __subscribe_handler(GVariant *parameters, GAsyncReadyCallback callback, gpointer user_data) +{ + _gdbus_async_result.callback = callback; + _gdbus_async_result.result = g_variant_new("(qi)", DUMMY_SUBSCRIBE_ID, WIFI_AWARE_ERROR_NONE); + _gdbus_async_result.user_data = user_data; + g_timeout_add(ASYNC_RESULT_DELAY, __reply_async_method, &_gdbus_async_result); +} + +static void __update_subscribe_handler(GVariant *parameters, GAsyncReadyCallback callback, gpointer user_data) +{ + _gdbus_async_result.callback = callback; + _gdbus_async_result.result = g_variant_new("(qi)", DUMMY_SUBSCRIBE_ID, WIFI_AWARE_ERROR_NONE); + _gdbus_async_result.user_data = user_data; + g_timeout_add(ASYNC_RESULT_DELAY, __reply_async_method, &_gdbus_async_result); +} + +static GVariant *__cancel_subscribe_handler(GVariant *parameters) +{ + return g_variant_new("(i)", WIFI_AWARE_ERROR_NONE); } struct { @@ -69,20 +110,42 @@ struct { NULL, __disable_handler, }, - /* { "net.nan.discovery", "Publish", + __publish_handler, + NULL, }, { "net.nan.discovery", "UpdatePublish", + __update_publish_handler, + NULL, }, { "net.nan.discovery", "CancelPublish", + NULL, + __cancel_publish_handler, + }, + { + "net.nan.discovery", + "Subscribe", + __subscribe_handler, + NULL, + }, + { + "net.nan.discovery", + "UpdateSubscribe", + __update_subscribe_handler, + NULL, + }, + { + "net.nan.discovery", + "CancelSubscribe", + NULL, + __cancel_subscribe_handler, }, - */ { NULL, NULL, @@ -151,3 +214,10 @@ GVariant *_handle_sync_method(const gchar *interface_name, return wifi_aware_g_dbus_method_list[i].sync_handler(parameters); } } + +guint _signal_subscribe(const char *interface_name, + const char *member, + GDBusSignalCallback callback, gpointer user_data) +{ + return DUMMY_SIGNAL_ID; +} diff --git a/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.h b/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.h index edee2ba..2373285 100644 --- a/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.h +++ b/tests/unittest/mocks/wifi-aware-mock-gdbus-internal.h @@ -20,6 +20,9 @@ #define ASYNC_RESULT_DELAY 500 #define DUMMY_CLIENT_ID 1 +#define DUMMY_SIGNAL_ID 1 +#define DUMMY_PUBLISH_ID 1 +#define DUMMY_SUBSCRIBE_ID 1 GDBusConnection *_get_dummy_gdbus_connection(); bool _check_g_dbus_bus_name(const gchar *bus_name); @@ -32,3 +35,6 @@ GVariant *_get_gdbus_async_result(GError **error); 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); +guint _signal_subscribe(const char *interface_name, + const char *member, + GDBusSignalCallback callback, gpointer user_data); diff --git a/tests/unittest/mocks/wifi-aware-mock.c b/tests/unittest/mocks/wifi-aware-mock.c index 4fb3878..7ceaa05 100644 --- a/tests/unittest/mocks/wifi-aware-mock.c +++ b/tests/unittest/mocks/wifi-aware-mock.c @@ -97,3 +97,22 @@ GVariant *g_dbus_connection_call_sync(GDBusConnection *connection, } return _handle_sync_method(interface_name, method_name, parameters, error); } + +guint g_dbus_connection_signal_subscribe(GDBusConnection *connection, + const gchar *sender, + const gchar *interface_name, + const gchar *member, + const gchar *object_path, + const gchar *arg0, + GDBusSignalFlags flags, + GDBusSignalCallback callback, + gpointer user_data, + GDestroyNotify user_data_free_func) +{ + return _signal_subscribe(interface_name, member, callback, user_data); +} + +void g_dbus_connection_signal_unsubscribe(GDBusConnection *connection, + guint subscription_id) +{ +} diff --git a/tests/unittest/wifi-aware-publish-unittest-fixture.h b/tests/unittest/wifi-aware-publish-unittest-fixture.h new file mode 100644 index 0000000..0dc3c52 --- /dev/null +++ b/tests/unittest/wifi-aware-publish-unittest-fixture.h @@ -0,0 +1,35 @@ +/* + * 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 + +#include "wifi-aware-unittest-fixture.h" + +wifi_aware_publish_h g_publish_config = NULL; + +class WifiAwarePublish : public WifiAware +{ +protected: + virtual void SetUp() { + WifiAware::SetUp(); + wifi_aware_publish_create(&g_publish_config); + } + + virtual void TearDown() { + wifi_aware_publish_destroy(g_publish_config); + WifiAware::TearDown(); + } +}; diff --git a/tests/unittest/wifi-aware-publish-unittest.cpp b/tests/unittest/wifi-aware-publish-unittest.cpp new file mode 100644 index 0000000..15fd593 --- /dev/null +++ b/tests/unittest/wifi-aware-publish-unittest.cpp @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2019-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 +#include + +#include "wifi-aware-publish-unittest-fixture.h" +#include "wifi-aware.h" + +TEST_F(WifiAwarePublish, wifi_aware_publish_create_p) +{ + int ret = 0; + wifi_aware_publish_h publish_config = NULL; + + ret = wifi_aware_publish_create(&publish_config); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_create"); + + wifi_aware_publish_destroy(publish_config); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_create_n) +{ + int ret = 0; + + ret = wifi_aware_publish_create(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_create"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_destroy_p) +{ + int ret = 0; + wifi_aware_publish_h publish_config = NULL; + + wifi_aware_publish_create(&publish_config); + + ret = wifi_aware_publish_destroy(publish_config); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_destroy"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_destroy_n) +{ + int ret = 0; + + ret = wifi_aware_publish_destroy(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_destroy"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_ttl_p) +{ + int ret = 0; + + ret = wifi_aware_publish_set_ttl(g_publish_config, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_ttl"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_ttl_n) +{ + int ret = 0; + + ret = wifi_aware_publish_set_ttl(NULL, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_ttl"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_p) +{ + int ret = 0; + + ret = wifi_aware_publish_set_type(g_publish_config, WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_type"); + + ret = wifi_aware_publish_set_type(g_publish_config, WIFI_AWARE_PUBLISH_TYPE_SOLICITED); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_type"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_n1) +{ + int ret = 0; + + ret = wifi_aware_publish_set_type(NULL, WIFI_AWARE_PUBLISH_TYPE_UNSOLICITED); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_type"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_n2) +{ + int ret = 0; + + ret = wifi_aware_publish_set_type(g_publish_config, (wifi_aware_publish_type_e)-1); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_type"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_name_p) +{ + int ret = 0; + + ret = wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_service_name"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_name_n) +{ + int ret = 0; + + ret = wifi_aware_publish_set_service_name(NULL, SERVICE_NAME); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_service_name"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_p) +{ + int ret = 0; + + unsigned char info[255] = {0, }; + memcpy(info, SERVICE_INFO, strlen(SERVICE_INFO)); + ret = wifi_aware_publish_set_service_specific_info(g_publish_config, info, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_service_specific_info"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_n) +{ + int ret = 0; + + unsigned char info[255] = {0, }; + memcpy(info, SERVICE_INFO, strlen(SERVICE_INFO)); + ret = wifi_aware_publish_set_service_specific_info(NULL, info, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_service_specific_info"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_p) +{ + int ret = 0; + + unsigned char filter[255] = {0, }; + memcpy(filter, MATCH_FILTER, strlen(MATCH_FILTER)); + ret = wifi_aware_publish_set_match_filter(g_publish_config, filter, 12); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_set_match_filter"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_n) +{ + int ret = 0; + + unsigned char filter[255] = {0, }; + memcpy(filter, MATCH_FILTER, strlen(MATCH_FILTER)); + ret = wifi_aware_publish_set_match_filter(NULL, filter, 12); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_set_match_filter"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_enable_ranging_p) +{ + int ret = 0; + + ret = wifi_aware_publish_enable_ranging(g_publish_config, true); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_enable_ranging"); +} + +TEST_F(WifiAwarePublish, wifi_aware_publish_enable_ranging_n) +{ + int ret = 0; + + ret = wifi_aware_publish_enable_ranging(NULL, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_publish_enable_ranging"); +} diff --git a/tests/unittest/wifi-aware-session-unittest-fixture.h b/tests/unittest/wifi-aware-session-unittest-fixture.h new file mode 100644 index 0000000..8c18cf5 --- /dev/null +++ b/tests/unittest/wifi-aware-session-unittest-fixture.h @@ -0,0 +1,54 @@ +/* + * 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 + +#include "wifi-aware-unittest-fixture.h" + +class WifiAwareSession : public WifiAware +{ +protected: + virtual void SetUp() { + g_published = false; + g_subscribed = false; + WifiAware::SetUp(); + wifi_aware_enable(WifiAware::__enabled_cb, NULL); + RUN_GMAIN_LOOP; + } + + virtual void TearDown() { + wifi_aware_disable(); + WifiAware::TearDown(); + } + +public: + static void __published_cb(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data); + static void __subscribed_cb(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data); + static void __discovered_cb(wifi_aware_session_h session, + wifi_aware_peer_h peer, + const unsigned char *service_specific_info, size_t service_specific_info_len, + int distance, void *user_data); + static void __send_reply(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data); + static void __received_cb(wifi_aware_session_h session, + wifi_aware_peer_h peer, + const unsigned char *message, size_t len, void *user_data); + + static bool g_published; + static bool g_subscribed; +}; diff --git a/tests/unittest/wifi-aware-session-unittest.cpp b/tests/unittest/wifi-aware-session-unittest.cpp new file mode 100644 index 0000000..82795b8 --- /dev/null +++ b/tests/unittest/wifi-aware-session-unittest.cpp @@ -0,0 +1,770 @@ +/* + * Copyright (c) 2019-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 +#include + +#include "wifi-aware-session-unittest-fixture.h" +#include "wifi-aware.h" + +bool WifiAwareSession::g_published; +bool WifiAwareSession::g_subscribed; + +void WifiAwareSession::__published_cb(wifi_aware_session_h session, wifi_aware_error_e error, void *user_data) +{ + if (error == WIFI_AWARE_ERROR_NONE) + g_published = true; + QUIT_GMAIN_LOOP; +} + +void WifiAwareSession::__subscribed_cb(wifi_aware_session_h session, wifi_aware_error_e error, void *user_data) +{ + if (error == WIFI_AWARE_ERROR_NONE) + g_subscribed = true; + QUIT_GMAIN_LOOP; +} + +void WifiAwareSession::__discovered_cb(wifi_aware_session_h session, wifi_aware_peer_h peer, + const unsigned char *service_specific_info, size_t service_specific_info_len, + int distance, void *user_data) +{ +} + +void WifiAwareSession::__send_reply(wifi_aware_session_h session, + wifi_aware_error_e error, void *user_data) +{ +} + + +void WifiAwareSession::__received_cb(wifi_aware_session_h session, wifi_aware_peer_h peer, + const unsigned char *message, size_t len, void *user_data) +{ +} + +TEST_F(WifiAwareSession, wifi_aware_session_create_p1) +{ + wifi_aware_session_h session; + int ret = 0; + + ret = wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_create"); + + ret = wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_create_p2) +{ + wifi_aware_session_h session; + int ret = 0; + + ret = wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_create"); + + ret = wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_create_n1) +{ + wifi_aware_session_h session; + int ret = 0; + + ret = wifi_aware_session_create((wifi_aware_session_type_e)2, &session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_create"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_create_n2) +{ + int ret = 0; + + ret = wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_create"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_destroy_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_destroy(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_destroy"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_destroy_n) +{ + int ret = 0; + + ret = wifi_aware_session_destroy(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_destroy"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_terminated_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_set_terminated_cb(session, NULL, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_set_terminated_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_terminated_cb_n) +{ + int ret = 0; + + ret = wifi_aware_session_set_terminated_cb(NULL, NULL, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_set_terminated_cb"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_terminated_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_unset_terminated_cb(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_unset_terminated_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_terminated_cb_n) +{ + int ret = 0; + + ret = wifi_aware_session_unset_terminated_cb(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_unset_terminated_cb"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_publish_p) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_publish(session, + publish_config, WifiAwareSession::__published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_publish"); + + RUN_GMAIN_LOOP; + CHECK_RESULT(g_published, true, "wifi_aware_session_publish"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +/** + * session is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_publish_n1) +{ + wifi_aware_publish_h publish_config; + int ret = 0; + + wifi_aware_publish_create(&publish_config); + + ret = wifi_aware_session_publish(NULL, publish_config, WifiAwareSession::__published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_publish"); + + wifi_aware_publish_destroy(publish_config); +} + +/** + * publish_config is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_publish_n2) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_publish(session, NULL, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_publish"); + + wifi_aware_session_destroy(session); +} + +/** + * Invalid session type + * WIFI_AWARE_ERROR_INVALID_OPERATION + */ +TEST_F(WifiAwareSession, wifi_aware_session_publish_n3) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_publish_create(&publish_config); + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_publish"); + + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +/** + * Two consecutive publish request + * WIFI_AWARE_ERROR_NOW_IN_PROGRESS + */ +TEST_F(WifiAwareSession, wifi_aware_session_publish_n4) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_publish"); + + ret = wifi_aware_session_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NOW_IN_PROGRESS, "wifi_aware_session_publish"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + +} + +TEST_F(WifiAwareSession, wifi_aware_session_update_publish_p) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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_publish(session, publish_config, __published_cb, NULL); + + RUN_GMAIN_LOOP; + + g_published = false; + ret = wifi_aware_session_update_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_update_publish"); + + RUN_GMAIN_LOOP; + CHECK_RESULT(g_published, true, "wifi_aware_session_update_publish"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +/** + * Session has not been published + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n1) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_update_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_update_publish"); + + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +/** + * session is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n2) +{ + wifi_aware_publish_h publish_config; + int ret = 0; + + wifi_aware_publish_create(&publish_config); + + ret = wifi_aware_session_update_publish(NULL, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_update_publish"); + + wifi_aware_publish_destroy(publish_config); +} + +/** + * publish_config is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n3) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_update_publish(session, NULL, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_update_publish"); + + wifi_aware_session_destroy(session); +} + +/** + * Invalid session type + * WIFI_AWARE_ERROR_INVALID_OPERATION + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n4) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_publish_create(&publish_config); + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_update_publish(session, publish_config, __published_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_update_publish"); + + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +TEST_F(WifiAwareSession, wifi_aware_session_subscribe_p) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_subscribe"); + + RUN_GMAIN_LOOP; + CHECK_RESULT(g_subscribed, true, "wifi_aware_session_subscribe"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * session is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n1) +{ + wifi_aware_subscribe_h subscribe_config; + int ret = 0; + + wifi_aware_subscribe_create(&subscribe_config); + + ret = wifi_aware_session_subscribe(NULL, subscribe_config, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_subscribe"); + + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * subscribe_config is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n2) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_subscribe(session, NULL, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_subscribe"); + + wifi_aware_session_destroy(session); +} + +/** + * Invalid session type + * WIFI_AWARE_ERROR_INVALID_OPERATION + */ +TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n3) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_subscribe_create(&subscribe_config); + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_subscribe"); + + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * Two consecutive subscribe request + * WIFI_AWARE_ERROR_NOW_IN_PROGRESS + */ +TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n4) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_subscribe"); + + ret = wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NOW_IN_PROGRESS, "wifi_aware_session_subscribe"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + +} + +TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_p) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + 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_subscribe(session, subscribe_config, __subscribed_cb, NULL); + + RUN_GMAIN_LOOP; + + g_subscribed = false; + ret = wifi_aware_session_update_subscribe(session, subscribe_config, __subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_update_subscribe"); + + RUN_GMAIN_LOOP; + CHECK_RESULT(g_subscribed, true, "wifi_aware_session_update_subscribe"); + + wifi_aware_session_stop(session); + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * Session has not been subscribed + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n1) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_update_subscribe(session, subscribe_config, __subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_update_subscribe"); + + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * session is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n2) +{ + wifi_aware_subscribe_h subscribe_config; + int ret = 0; + + wifi_aware_subscribe_create(&subscribe_config); + + ret = wifi_aware_session_update_subscribe(NULL, subscribe_config, __subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_update_subscribe"); + + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * subscribe_config is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n3) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_update_subscribe(session, NULL, __subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_update_subscribe"); + + wifi_aware_session_destroy(session); +} + +/** + * Invalid session type + * WIFI_AWARE_ERROR_INVALID_OPERATION + */ +TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n4) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_subscribe_create(&subscribe_config); + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_update_subscribe(session, subscribe_config, __subscribed_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_update_subscribe"); + + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +TEST_F(WifiAwareSession, wifi_aware_session_stop_p) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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_publish(session, publish_config, __published_cb, NULL); + + RUN_GMAIN_LOOP; + + ret = wifi_aware_session_stop(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_stop"); + + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + + +/** + * Session has not been published + */ +TEST_F(WifiAwareSession, wifi_aware_session_stop_n1) +{ + wifi_aware_publish_h publish_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_stop(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_stop"); + + wifi_aware_session_destroy(session); + wifi_aware_publish_destroy(publish_config); +} + +/** + * Session has not been subscribed + */ +TEST_F(WifiAwareSession, wifi_aware_session_stop_n2) +{ + wifi_aware_subscribe_h subscribe_config; + wifi_aware_session_h session; + int ret = 0; + + 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); + + ret = wifi_aware_session_stop(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_stop"); + + wifi_aware_session_destroy(session); + wifi_aware_subscribe_destroy(subscribe_config); +} + +/** + * session is NULL + */ +TEST_F(WifiAwareSession, wifi_aware_session_stop_n3) +{ + int ret = 0; + + ret = wifi_aware_session_stop(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_stop"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_set_service_discovered_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_n1) +{ + int ret = 0; + + ret = wifi_aware_session_set_service_discovered_cb(NULL, __discovered_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_set_service_discovered_cb"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_n2) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session); + + ret = wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_set_service_discovered_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_n3) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_set_service_discovered_cb(session, NULL, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_set_service_discovered_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_service_discovered_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL); + + ret = wifi_aware_session_unset_service_discovered_cb(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_unset_service_discovered_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_service_discovered_cb_n) +{ + int ret = 0; + + ret = wifi_aware_session_unset_service_discovered_cb(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_unset_service_discovered_cb"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_send_message_n1) +{ + wifi_aware_session_h session; + int ret = 0; + unsigned char message[255] = {0, }; + memcpy(message, "MESSAGE", 7); + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_send_message(session, NULL, message, 7, __send_reply, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_send_message"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_send_message_n2) +{ + int ret = 0; + unsigned char message[255] = {0, }; + memcpy(message, "MESSAGE", 7); + + ret = wifi_aware_session_send_message(NULL, NULL, message, 7, __send_reply, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_send_message"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_message_received_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_set_message_received_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_message_received_cb_n1) +{ + int ret = 0; + + ret = wifi_aware_session_set_message_received_cb(NULL, WifiAwareSession::__received_cb, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_set_message_received_cb"); +} + +TEST_F(WifiAwareSession, wifi_aware_session_set_message_received_cb_n2) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + + ret = wifi_aware_session_set_message_received_cb(session, NULL, NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_set_message_received_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_message_received_cb_p) +{ + wifi_aware_session_h session; + int ret = 0; + + wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session); + wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL); + + ret = wifi_aware_session_unset_message_received_cb(session); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_unset_message_received_cb"); + + wifi_aware_session_destroy(session); +} + +TEST_F(WifiAwareSession, wifi_aware_session_unset_message_received_cb_n) +{ + int ret = 0; + + ret = wifi_aware_session_unset_message_received_cb(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_unset_message_received_cb"); +} + diff --git a/tests/unittest/wifi-aware-subscribe-unittest-fixture.h b/tests/unittest/wifi-aware-subscribe-unittest-fixture.h new file mode 100644 index 0000000..7080207 --- /dev/null +++ b/tests/unittest/wifi-aware-subscribe-unittest-fixture.h @@ -0,0 +1,36 @@ +/* + * 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 + +#include "wifi-aware-unittest-fixture.h" + +wifi_aware_subscribe_h g_subscribe_config = NULL; + +class WifiAwareSubscribe : public WifiAware +{ +protected: + virtual void SetUp() { + WifiAware::SetUp(); + wifi_aware_subscribe_create(&g_subscribe_config); + } + + virtual void TearDown() { + wifi_aware_subscribe_destroy(g_subscribe_config); + WifiAware::TearDown(); + } +}; + diff --git a/tests/unittest/wifi-aware-subscribe-unittest.cpp b/tests/unittest/wifi-aware-subscribe-unittest.cpp new file mode 100644 index 0000000..2ab26fe --- /dev/null +++ b/tests/unittest/wifi-aware-subscribe-unittest.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 2019-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 +#include + +#include "wifi-aware-subscribe-unittest-fixture.h" +#include "wifi-aware.h" + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_create_p) +{ + int ret = 0; + wifi_aware_subscribe_h subscribe_config = NULL; + + ret = wifi_aware_subscribe_create(&subscribe_config); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_create"); + + wifi_aware_subscribe_destroy(subscribe_config); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_create_n) +{ + int ret = 0; + + ret = wifi_aware_subscribe_create(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_create"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_destroy_p) +{ + int ret = 0; + wifi_aware_subscribe_h subscribe_config = NULL; + + wifi_aware_subscribe_create(&subscribe_config); + + ret = wifi_aware_subscribe_destroy(subscribe_config); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_destroy"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_destroy_n) +{ + int ret = 0; + + ret = wifi_aware_subscribe_destroy(NULL); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_destroy"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_ttl_p) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_ttl(g_subscribe_config, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_ttl"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_ttl_n) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_ttl(NULL, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_ttl"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_p) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_type(g_subscribe_config, WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_type"); + + ret = wifi_aware_subscribe_set_type(g_subscribe_config, WIFI_AWARE_SUBSCRIBE_TYPE_ACTIVE); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_type"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_n1) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_type(NULL, WIFI_AWARE_SUBSCRIBE_TYPE_PASSIVE); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_type"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_n2) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_type(g_subscribe_config, (wifi_aware_subscribe_type_e)-1); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_type"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_name_p) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_service_name"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_name_n) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_service_name(NULL, SERVICE_NAME); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_service_name"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_p) +{ + int ret = 0; + + unsigned char info[255] = {0, }; + memcpy(info, SERVICE_INFO, strlen(SERVICE_INFO)); + ret = wifi_aware_subscribe_set_service_specific_info(g_subscribe_config, info, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_service_specific_info"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_n) +{ + int ret = 0; + + unsigned char info[255] = {0, }; + memcpy(info, SERVICE_INFO, strlen(SERVICE_INFO)); + ret = wifi_aware_subscribe_set_service_specific_info(NULL, info, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_service_specific_info"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_p) +{ + int ret = 0; + + unsigned char filter[255] = {0, }; + memcpy(filter, MATCH_FILTER, strlen(MATCH_FILTER)); + ret = wifi_aware_subscribe_set_match_filter(g_subscribe_config, filter, 12); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_match_filter"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_n) +{ + int ret = 0; + + unsigned char filter[255] = {0, }; + memcpy(filter, MATCH_FILTER, strlen(MATCH_FILTER)); + ret = wifi_aware_subscribe_set_match_filter(NULL, filter, 12); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_match_filter"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_p) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_max_distance(g_subscribe_config, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_max_distance"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_n1) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_max_distance(NULL, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_max_distance"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_n2) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_max_distance(g_subscribe_config, 0); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_max_distance"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_p) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_min_distance(g_subscribe_config, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_set_min_distance"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_n1) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_min_distance(NULL, 10); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_min_distance"); +} + +TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_n2) +{ + int ret = 0; + + ret = wifi_aware_subscribe_set_min_distance(g_subscribe_config, -1); + CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_subscribe_set_min_distance"); +} diff --git a/tests/unittest/wifi-aware-unittest-fixture.h b/tests/unittest/wifi-aware-unittest-fixture.h index 60d70b0..2c8afe0 100644 --- a/tests/unittest/wifi-aware-unittest-fixture.h +++ b/tests/unittest/wifi-aware-unittest-fixture.h @@ -20,19 +20,18 @@ #include #include "wifi-aware.h" +#include "wifi-aware-unittest-util.h" #define WIFI_AWARE_FEATURE "http://tizen.org/feature/network.wifi.aware" -bool g_enabled; -bool g_wifi_aware_supported; - class WifiAware : public ::testing::Test { protected: virtual void SetUp() { g_enabled = false; g_wifi_aware_supported = false; - system_info_get_platform_bool(WIFI_AWARE_FEATURE, &g_wifi_aware_supported); + system_info_get_platform_bool(WIFI_AWARE_FEATURE, + &WifiAware::g_wifi_aware_supported); wifi_aware_initialize(); } @@ -40,4 +39,12 @@ protected: wifi_aware_deinitialize(); } +public: + static gboolean _wifi_aware_callback_timeout(gpointer data); + static void __enabled_cb(wifi_aware_error_e error, void *user_data); + + static GMainLoop *g_main_loop; + static guint g_timeout_id; + static bool g_enabled; + static bool g_wifi_aware_supported; }; diff --git a/tests/unittest/wifi-aware-unittest-util.cpp b/tests/unittest/wifi-aware-unittest-util.cpp index 3193cb0..96fcea1 100644 --- a/tests/unittest/wifi-aware-unittest-util.cpp +++ b/tests/unittest/wifi-aware-unittest-util.cpp @@ -16,20 +16,6 @@ #include "wifi-aware-unittest-util.h" -GMainLoop *g_main_loop; -guint g_timeout_id; - -gboolean _wifi_aware_callback_timeout(gpointer data) -{ - GMainLoop *main_loop = NULL; - main_loop = (GMainLoop *)data; - if (main_loop != NULL) - { - g_main_loop_quit(main_loop); - } - return false; -} - const char *_convert_error_to_string(wifi_aware_error_e error) { switch (error) { diff --git a/tests/unittest/wifi-aware-unittest-util.h b/tests/unittest/wifi-aware-unittest-util.h index 8b746a2..f78a317 100644 --- a/tests/unittest/wifi-aware-unittest-util.h +++ b/tests/unittest/wifi-aware-unittest-util.h @@ -20,9 +20,8 @@ #include "wifi-aware.h" #define CHECK_WIFI_AWARE_SUPPORTED(ret) do { \ - if (!g_wifi_aware_supported) { \ - ASSERT_EQ(ret, WIFI_AWARE_ERROR_NOT_SUPPORTED) \ - << "FAIL NOT_SUPPORTED"; \ + if (!WifiAware::g_wifi_aware_supported) { \ + ASSERT_EQ(ret, WIFI_AWARE_ERROR_NOT_SUPPORTED) << "FAIL NOT_SUPPORTED"; \ } \ } while (0) @@ -33,19 +32,23 @@ #define CALLBACK_TIMEOUT 20000 #define RUN_GMAIN_LOOP do { \ - g_main_loop = g_main_loop_new(NULL, false); \ - g_timeout_id = g_timeout_add(CALLBACK_TIMEOUT, _wifi_aware_callback_timeout, g_main_loop); \ - g_main_loop_run(g_main_loop); \ - g_source_remove(g_timeout_id); \ - g_main_loop = NULL; \ + 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); \ + WifiAware::g_main_loop = NULL; \ } while (0) #define QUIT_GMAIN_LOOP do { \ - if (g_main_loop) { \ - g_main_loop_quit(g_main_loop); \ - g_main_loop = NULL; \ + if (WifiAware::g_main_loop) { \ + g_main_loop_quit(WifiAware::g_main_loop); \ + WifiAware::g_main_loop = NULL; \ } \ } while (0) -gboolean _wifi_aware_callback_timeout(gpointer data); +#define SERVICE_NAME "NanService" +#define SERVICE_INFO "ServiceInfo" +#define MATCH_FILTER "Match Filter" + const char *_convert_error_to_string(wifi_aware_error_e error); diff --git a/tests/unittest/wifi-aware-unittest.cpp b/tests/unittest/wifi-aware-unittest.cpp index d4e6fab..f3e3526 100644 --- a/tests/unittest/wifi-aware-unittest.cpp +++ b/tests/unittest/wifi-aware-unittest.cpp @@ -18,17 +18,30 @@ #include #include "wifi-aware-unittest-fixture.h" -#include "wifi-aware-unittest-util.h" #include "wifi-aware.h" -extern GMainLoop *g_main_loop; -extern guint g_timeout_id; +GMainLoop *WifiAware::g_main_loop; +guint WifiAware::g_timeout_id; -void __enabled_cb(wifi_aware_error_e error, void *user_data) +bool WifiAware::g_enabled; +bool WifiAware::g_wifi_aware_supported; + +gboolean WifiAware::_wifi_aware_callback_timeout(gpointer data) +{ + GMainLoop *main_loop = NULL; + main_loop = (GMainLoop *)data; + if (main_loop != NULL) + { + g_main_loop_quit(main_loop); + } + return false; +} + +void WifiAware::__enabled_cb(wifi_aware_error_e error, void *user_data) { if (error == WIFI_AWARE_ERROR_NONE) { // LOGI("Successfully Enabled"); - g_enabled = true; + WifiAware::g_enabled = true; } else { // LOGE("Fail to enable %s(%d)", _wifi_aware_error_to_string(error), error); @@ -73,12 +86,12 @@ TEST_F(WifiAware, wifi_aware_enable_p) { int ret = 0; - ret = wifi_aware_enable(__enabled_cb, NULL); + ret = wifi_aware_enable(WifiAware::__enabled_cb, NULL); CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_enable"); RUN_GMAIN_LOOP; - ASSERT_TRUE(g_enabled) << "FAIL Enabled"; + ASSERT_TRUE(WifiAware::g_enabled) << "FAIL Enabled"; wifi_aware_disable(); }