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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
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 (file)
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 <iostream>
+#include <gtest/gtest.h>
+
+#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 (file)
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 (file)
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 <iostream>
+#include <gtest/gtest.h>
+
+#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 (file)
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 (file)
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 <iostream>
+#include <gtest/gtest.h>
+
+#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 (file)
--- a/tests/unittest/wifi-aware-unittest-fixture.h
+++ b/tests/unittest/wifi-aware-unittest-fixture.h
@@ -20,19 +20,18 @@
 #include <system_info.h>
 
 #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 (file)
--- 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 (file)
--- 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 (file)
--- a/tests/unittest/wifi-aware-unittest.cpp
+++ b/tests/unittest/wifi-aware-unittest.cpp
@@ -18,17 +18,30 @@
 #include <gtest/gtest.h>
 
 #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();
 }