Add unittests for peer and data-path

Change-Id: I5422cc67faca70695155b234d5ea670fb73b8d29

diff --git a/tests/unittest/wifi-aware-data-path-unittest-fixture.h b/tests/unittest/wifi-aware-data-path-unittest-fixture.h
new file mode 100644 (file)
index 0000000..2526d71
--- /dev/null
+++ b/tests/unittest/wifi-aware-data-path-unittest-fixture.h
@@ -0,0 +1,52 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <system_info.h>
+
+#include "wifi-aware.h"
+#include  "wifi-aware-unittest-fixture.h"
+
+class WifiAwareDataPath : public WifiAware
+{
+protected:
+       virtual void SetUp()
+       {
+               WifiAware::SetUp();
+               g_session = __create_dummy_session(WIFI_AWARE_SESSION_SUBSCRIBE);
+               g_peer = __create_dummy_peer();
+               g_data_path = __create_dummy_data_path();
+       }
+
+       virtual void TearDown()
+       {
+               __destroy_dummy_session(g_session);
+               __destroy_dummy_peer(g_peer);
+               __destroy_dummy_data_path(g_data_path);
+               g_session = NULL;
+               g_peer = NULL;
+               g_data_path = NULL;
+
+               WifiAware::TearDown();
+       }
+
+       wifi_aware_session_h g_session;
+       wifi_aware_peer_h g_peer;
+       wifi_aware_data_path_h g_data_path;
+
+};

diff --git a/tests/unittest/wifi-aware-data-path-unittest.cpp b/tests/unittest/wifi-aware-data-path-unittest.cpp
new file mode 100644 (file)
index 0000000..1fc747e
--- /dev/null
+++ b/tests/unittest/wifi-aware-data-path-unittest.cpp
@@ -0,0 +1,265 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include "wifi-aware-data-path-unittest-fixture.h"
+#include "wifi-aware.h"
+
+static void __terminated_cb(wifi_aware_data_path_h data_path,
+               wifi_aware_termination_reason_e reason, void *user_data)
+{
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_create_p)
+{
+       wifi_aware_data_path_h data_path;
+       int ret = 0;
+
+       ret = wifi_aware_data_path_create(g_session, g_peer, &data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_create");
+       ASSERT_NE(nullptr, data_path) << "data_path is NULL";
+
+       wifi_aware_data_path_destroy(data_path);
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_create_n)
+{
+       wifi_aware_data_path_h data_path;
+       int ret = 0;
+
+       ret = wifi_aware_data_path_create(g_session, NULL, &data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_create");
+
+       ret = wifi_aware_data_path_create(NULL, NULL, &data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_create");
+
+       ret = wifi_aware_data_path_create(NULL, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_create");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_security_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_security(g_data_path, WIFI_AWARE_SECURITY_TYPE_OPEN);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_set_security");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_security_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_security(NULL, WIFI_AWARE_SECURITY_TYPE_OPEN);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_security");
+
+       ret = wifi_aware_data_path_set_security(g_data_path, (wifi_aware_security_type_e)-1);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_security");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_psk_p)
+{
+       int ret = 0;
+
+       wifi_aware_data_path_set_security(g_data_path, WIFI_AWARE_SECURITY_TYPE_PSK);
+
+       ret = wifi_aware_data_path_set_psk(g_data_path, "12345678");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_set_psk");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_psk_n)
+{
+       int ret = 0;
+
+       wifi_aware_data_path_set_security(g_data_path, WIFI_AWARE_SECURITY_TYPE_PSK);
+
+       ret = wifi_aware_data_path_set_psk(NULL, "12345678!!!");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_psk");
+
+       ret = wifi_aware_data_path_set_psk(g_data_path, "123");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_psk");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_pmk_p)
+{
+       int ret = 0;
+       unsigned char pmk[PMK_LEN] = {0, };
+
+       wifi_aware_data_path_set_security(g_data_path, WIFI_AWARE_SECURITY_TYPE_PMK);
+
+       ret = wifi_aware_data_path_set_pmk(g_data_path, pmk);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_set_pmk");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_pmk_n)
+{
+       int ret = 0;
+
+       wifi_aware_data_path_set_security(g_data_path, WIFI_AWARE_SECURITY_TYPE_PMK);
+
+       ret = wifi_aware_data_path_set_pmk(NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_pmk");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_port_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_port(g_data_path, 12345);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_set_port");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_port_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_port(NULL, 12345);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_port");
+
+       ret = wifi_aware_data_path_set_port(g_data_path, 70000);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_port");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_destroy_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_destroy(g_data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_destroy");
+       g_data_path = NULL;
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_destroy_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_destroy(NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_destroy");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_open_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_open(NULL, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_data_path_open");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_close_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_close(g_data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_data_path_close");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_peer_port_p)
+{
+       int ret = 0;
+       int port = -1;
+
+       ret = wifi_aware_data_path_get_peer_port(g_data_path, &port);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_get_peer_port");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_peer_port_n)
+{
+       int ret = 0;
+       int port = -1;
+
+       ret = wifi_aware_data_path_get_peer_port(NULL, &port);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_peer_port");
+
+       ret = wifi_aware_data_path_get_peer_port(g_data_path, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_peer_port");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_peer_ipv6_address_p)
+{
+       int ret = 0;
+       char *ipv6 = NULL;
+
+       ret = wifi_aware_data_path_get_peer_ipv6_address(g_data_path, &ipv6);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_get_peer_ipv6_address");
+       free(ipv6);
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_peer_ipv6_address_n)
+{
+       int ret = 0;
+       char *ip6 = NULL;
+
+       ret = wifi_aware_data_path_get_peer_ipv6_address(NULL, &ip6);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_peer_ipv6_address");
+
+       ret = wifi_aware_data_path_get_peer_ipv6_address(g_data_path, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_peer_ipv6_address");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_interface_p)
+{
+       int ret = 0;
+       char *interface = NULL;
+
+       ret = wifi_aware_data_path_get_interface(g_data_path, &interface);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_get_interface");
+       free(interface);
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_get_interface_n)
+{
+       int ret = 0;
+       char *interface = NULL;
+
+       ret = wifi_aware_data_path_get_interface(NULL, &interface);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_interface");
+
+       ret = wifi_aware_data_path_get_interface(g_data_path, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_get_interface");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_terminated_cb_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_terminated_cb(g_data_path, __terminated_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_set_terminated_cb");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_set_terminated_cb_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_set_terminated_cb(NULL, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_set_terminated_cb");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_unset_terminated_cb_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_unset_terminated_cb(g_data_path);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_data_path_unset_terminated_cb");
+}
+
+TEST_F(WifiAwareDataPath, wifi_aware_data_path_unset_terminated_cb_n)
+{
+       int ret = 0;
+
+       ret = wifi_aware_data_path_unset_terminated_cb(NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_data_path_unset_terminated_cb");
+}
+

diff --git a/tests/unittest/wifi-aware-peer-unittest-fixture.h b/tests/unittest/wifi-aware-peer-unittest-fixture.h
new file mode 100644 (file)
index 0000000..a4b65ec
--- /dev/null
+++ b/tests/unittest/wifi-aware-peer-unittest-fixture.h
@@ -0,0 +1,41 @@
+/*
+ * 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.h"
+#include "wifi-aware-unittest-fixture.h"
+
+#include "wifi-aware-mock-interface.h"
+
+class WifiAwarePeer: public WifiAware
+{
+protected:
+       virtual void SetUp()
+       {
+               WifiAware::SetUp();
+               g_peer = __create_dummy_peer();
+       }
+
+       virtual void TearDown()
+       {
+               __destroy_dummy_peer(g_peer);
+               g_peer = NULL;
+               WifiAware::TearDown();
+       }
+
+       wifi_aware_peer_h g_peer;
+};

diff --git a/tests/unittest/wifi-aware-peer-unittest.cpp b/tests/unittest/wifi-aware-peer-unittest.cpp
new file mode 100644 (file)
index 0000000..a23687d
--- /dev/null
+++ b/tests/unittest/wifi-aware-peer-unittest.cpp
@@ -0,0 +1,50 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include "wifi-aware-peer-unittest-fixture.h"
+
+TEST_F(WifiAwarePeer, wifi_aware_peer_clone_p)
+{
+       wifi_aware_peer_h cloned_peer;
+       int ret = 0;
+
+       ret = wifi_aware_peer_clone(&cloned_peer, g_peer);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_peer_clone");
+       ASSERT_NE(nullptr, cloned_peer) << "cloned_peer is NULL";
+
+       wifi_aware_peer_destroy(cloned_peer);
+}
+
+TEST_F(WifiAwarePeer, wifi_aware_peer_destroy_p)
+{
+       int ret = 0;
+
+       ret = wifi_aware_peer_destroy(g_peer);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_peer_destroy");
+       g_peer = NULL;
+}
+
+TEST_F(WifiAwarePeer, wifi_aware_peer_get_mac_p)
+{
+       int ret = 0;
+       unsigned char *mac;
+
+       ret = wifi_aware_peer_get_mac(g_peer, &mac);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_peer_get_mac");
+       free(mac);
+}

diff --git a/tests/unittest/wifi-aware-publish-unittest-fixture.h b/tests/unittest/wifi-aware-publish-unittest-fixture.h
index aa32900..0efb0d4 100644 (file)
--- a/tests/unittest/wifi-aware-publish-unittest-fixture.h
+++ b/tests/unittest/wifi-aware-publish-unittest-fixture.h
@@ -18,8 +18,6 @@
 
 #include "wifi-aware-unittest-fixture.h"
 
-wifi_aware_publish_h g_publish_config = NULL;
-
 class WifiAwarePublish : public WifiAware
 {
 protected:
@@ -34,4 +32,7 @@ protected:
                wifi_aware_publish_destroy(g_publish_config);
                WifiAware::TearDown();
        }
+
+       wifi_aware_publish_h g_publish_config;
+
 };

diff --git a/tests/unittest/wifi-aware-publish-unittest.cpp b/tests/unittest/wifi-aware-publish-unittest.cpp
index 15fd593..25dd4a4 100644 (file)
--- a/tests/unittest/wifi-aware-publish-unittest.cpp
+++ b/tests/unittest/wifi-aware-publish-unittest.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <gtest/gtest.h>
 
 #include "wifi-aware-publish-unittest-fixture.h"
@@ -26,7 +25,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_create_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_create");
 
        wifi_aware_publish_destroy(publish_config);
 }
@@ -36,7 +35,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_create");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_destroy_p)
@@ -47,7 +46,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_destroy_p)
        wifi_aware_publish_create(&publish_config);
 
        ret = wifi_aware_publish_destroy(publish_config);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_publish_destroy");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_destroy");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_destroy_n)
@@ -55,7 +54,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_destroy");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_ttl_p)
@@ -63,7 +62,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_set_ttl");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_ttl_n)
@@ -71,7 +70,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_ttl");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_p)
@@ -79,10 +78,10 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_set_type");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_n1)
@@ -90,7 +89,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_type");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_type_n2)
@@ -98,7 +97,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_type");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_name_p)
@@ -106,7 +105,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_set_service_name");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_name_n)
@@ -114,7 +113,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_service_name");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_p)
@@ -124,7 +123,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_set_service_specific_info");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_n)
@@ -134,7 +133,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_set_service_specific_info_n)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_service_specific_info");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_p)
@@ -144,7 +143,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_set_match_filter");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_n)
@@ -154,7 +153,7 @@ TEST_F(WifiAwarePublish, wifi_aware_publish_set_match_filter_n)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_publish_set_match_filter");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_enable_ranging_p)
@@ -162,7 +161,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_publish_enable_ranging");
 }
 
 TEST_F(WifiAwarePublish, wifi_aware_publish_enable_ranging_n)
@@ -170,5 +169,5 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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
index e8999a0..cdc4242 100644 (file)
--- a/tests/unittest/wifi-aware-session-unittest-fixture.h
+++ b/tests/unittest/wifi-aware-session-unittest-fixture.h
@@ -38,7 +38,6 @@ protected:
                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,
@@ -57,4 +56,8 @@ public:
        static bool g_subscribed;
        static bool g_discovered;
        static bool g_message_received;
+
+       wifi_aware_publish_h g_publish_config;
+       wifi_aware_subscribe_h g_subscribe_config;
+       wifi_aware_session_h g_session;
 };

diff --git a/tests/unittest/wifi-aware-session-unittest.cpp b/tests/unittest/wifi-aware-session-unittest.cpp
index 8642dc8..572b2b9 100644 (file)
--- a/tests/unittest/wifi-aware-session-unittest.cpp
+++ b/tests/unittest/wifi-aware-session-unittest.cpp
@@ -14,15 +14,11 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <gtest/gtest.h>
 
 #include "wifi-aware-session-unittest-fixture.h"
 #include "wifi-aware.h"
-
-extern "C" {
 #include "wifi-aware-mock-interface.h"
-}
 
 bool WifiAwareSession::g_published;
 bool WifiAwareSession::g_subscribed;
@@ -66,33 +62,30 @@ void WifiAwareSession::__received_cb(wifi_aware_session_h session, wifi_aware_pe
 
 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_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_create");
 
-       ret = wifi_aware_session_destroy(session);
+       ret = wifi_aware_session_destroy(g_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_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_create");
 
-       ret = wifi_aware_session_destroy(session);
+       ret = wifi_aware_session_destroy(g_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");
+       ret = wifi_aware_session_create((wifi_aware_session_type_e)2, &g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_create");
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_create_n2)
@@ -100,18 +93,17 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_destroy(session);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_destroy");
+       ret = wifi_aware_session_destroy(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_destroy");
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_destroy_n)
@@ -119,20 +111,19 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_set_terminated_cb(session, NULL, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_set_terminated_cb");
+       ret = wifi_aware_session_set_terminated_cb(g_session, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_set_terminated_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_set_terminated_cb_n)
@@ -140,20 +131,19 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_unset_terminated_cb(session);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_unset_terminated_cb");
+       ret = wifi_aware_session_unset_terminated_cb(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_unset_terminated_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_unset_terminated_cb_n)
@@ -161,29 +151,27 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_publish(session,
-                       publish_config, WifiAwareSession::__published_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_session_publish");
+       ret = wifi_aware_session_publish(g_session,
+                       g_publish_config, WifiAwareSession::__published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
@@ -191,31 +179,29 @@ TEST_F(WifiAwareSession, wifi_aware_session_publish_p)
  */
 TEST_F(WifiAwareSession, wifi_aware_session_publish_n1)
 {
-       wifi_aware_publish_h publish_config;
        int ret = 0;
 
-       wifi_aware_publish_create(&publish_config);
+       wifi_aware_publish_create(&g_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");
+       ret = wifi_aware_session_publish(NULL, g_publish_config, WifiAwareSession::__published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_publish");
 
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
- * publish_config is NULL
+ * g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_publish(session, NULL, __published_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_publish");
+       ret = wifi_aware_session_publish(g_session, NULL, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_publish");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 /**
@@ -224,19 +210,17 @@ TEST_F(WifiAwareSession, wifi_aware_session_publish_n2)
  */
 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_publish_create(&g_publish_config);
 
-       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
 
-       ret = wifi_aware_session_publish(session, publish_config, __published_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_publish");
+       ret = wifi_aware_session_publish(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_publish");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
@@ -245,48 +229,44 @@ TEST_F(WifiAwareSession, wifi_aware_session_publish_n3)
  */
 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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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);
+       ret = wifi_aware_session_publish(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NOW_IN_PROGRESS, ret, "wifi_aware_session_publish");
 
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
+       wifi_aware_session_publish(g_session, g_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");
+       ret = wifi_aware_session_update_publish(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
@@ -294,19 +274,17 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_publish_p)
  */
 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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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");
+       ret = wifi_aware_session_update_publish(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_update_publish");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
@@ -314,31 +292,29 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n1)
  */
 TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n2)
 {
-       wifi_aware_publish_h publish_config;
        int ret = 0;
 
-       wifi_aware_publish_create(&publish_config);
+       wifi_aware_publish_create(&g_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");
+       ret = wifi_aware_session_update_publish(NULL, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_update_publish");
 
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
- * publish_config is NULL
+ * g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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");
+       ret = wifi_aware_session_update_publish(g_session, NULL, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_update_publish");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 /**
@@ -347,39 +323,35 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_publish_n3)
  */
 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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_update_publish(g_session, g_publish_config, __published_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_update_publish");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
@@ -387,31 +359,29 @@ TEST_F(WifiAwareSession, wifi_aware_session_subscribe_p)
  */
 TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n1)
 {
-       wifi_aware_subscribe_h subscribe_config;
        int ret = 0;
 
-       wifi_aware_subscribe_create(&subscribe_config);
+       wifi_aware_subscribe_create(&g_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");
+       ret = wifi_aware_session_subscribe(NULL, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_subscribe");
 
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
- * subscribe_config is NULL
+ * g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
 
-       ret = wifi_aware_session_subscribe(session, NULL, WifiAwareSession::__subscribed_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_PARAMETER, "wifi_aware_session_subscribe");
+       ret = wifi_aware_session_subscribe(g_session, NULL, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_subscribe");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 /**
@@ -420,18 +390,16 @@ TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n2)
  */
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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");
+       ret = wifi_aware_session_subscribe(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_subscribe");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
@@ -440,48 +408,45 @@ TEST_F(WifiAwareSession, wifi_aware_session_subscribe_n3)
  */
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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");
+       ret = wifi_aware_session_subscribe(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NOW_IN_PROGRESS, ret, "wifi_aware_session_subscribe");
 
-       wifi_aware_session_stop(session);
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 
 }
 
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
+       wifi_aware_session_subscribe(g_session, g_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");
+       ret = wifi_aware_session_update_subscribe(g_session, g_subscribe_config, __subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
@@ -489,19 +454,17 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_p)
  */
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_update_subscribe(g_session, g_subscribe_config, __subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_update_subscribe");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
@@ -509,31 +472,29 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n1)
  */
 TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n2)
 {
-       wifi_aware_subscribe_h subscribe_config;
        int ret = 0;
 
-       wifi_aware_subscribe_create(&subscribe_config);
+       wifi_aware_subscribe_create(&g_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");
+       ret = wifi_aware_session_update_subscribe(NULL, g_subscribe_config, __subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_update_subscribe");
 
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
- * subscribe_config is NULL
+ * g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_update_subscribe(g_session, NULL, __subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_update_subscribe");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 /**
@@ -542,38 +503,34 @@ TEST_F(WifiAwareSession, wifi_aware_session_update_subscribe_n3)
  */
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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");
+       ret = wifi_aware_session_update_subscribe(g_session, g_subscribe_config, __subscribed_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_update_subscribe");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
+       wifi_aware_session_publish(g_session, g_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");
+       ret = wifi_aware_session_stop(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_stop");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 
@@ -582,19 +539,17 @@ TEST_F(WifiAwareSession, wifi_aware_session_stop_p)
  */
 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);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       ret = wifi_aware_session_stop(session);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_stop");
+       ret = wifi_aware_session_stop(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_stop");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 /**
@@ -602,19 +557,17 @@ TEST_F(WifiAwareSession, wifi_aware_session_stop_n1)
  */
 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);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
 
-       ret = wifi_aware_session_stop(session);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_session_stop");
+       ret = wifi_aware_session_stop(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_stop");
 
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 /**
@@ -625,34 +578,30 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_set_service_discovered_cb(g_session, __discovered_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_set_service_discovered_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 // wifi_aware_service_discovered_cb is called
 TEST_F(WifiAwareSession, wifi_aware_service_discovered_cb_p)
 {
-       wifi_aware_subscribe_h subscribe_config;
-       wifi_aware_session_h session;
-
-       wifi_aware_subscribe_create(&subscribe_config);
-       wifi_aware_subscribe_set_service_name(subscribe_config, SERVICE_NAME);
-       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session);
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
 
-       wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL);
-       wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       wifi_aware_session_set_service_discovered_cb(g_session, __discovered_cb, NULL);
+       wifi_aware_session_subscribe(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
        RUN_GMAIN_LOOP;
 
        wifi_aware_mock_emit_gdbus_signal(SERVICE_DISCOVERED);
@@ -660,32 +609,29 @@ TEST_F(WifiAwareSession, wifi_aware_service_discovered_cb_p)
 
        CHECK_RESULT(g_discovered, true, "service_discovered_cb");
 
-       wifi_aware_session_stop(session);
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 // wifi_aware_service_discovered_cb is not called
 TEST_F(WifiAwareSession, wifi_aware_service_discovered_cb_n)
 {
-       wifi_aware_subscribe_h subscribe_config;
-       wifi_aware_session_h session;
+       wifi_aware_subscribe_create(&g_subscribe_config);
+       wifi_aware_subscribe_set_service_name(g_subscribe_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
 
-       wifi_aware_subscribe_create(&subscribe_config);
-       wifi_aware_subscribe_set_service_name(subscribe_config, SERVICE_NAME);
-       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &session);
-
-       wifi_aware_session_set_service_discovered_cb(session, __discovered_cb, NULL);
-       wifi_aware_session_subscribe(session, subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
+       wifi_aware_session_set_service_discovered_cb(g_session, __discovered_cb, NULL);
+       wifi_aware_session_subscribe(g_session, g_subscribe_config, WifiAwareSession::__subscribed_cb, NULL);
        RUN_GMAIN_LOOP;
 
        RUN_GMAIN_LOOP;
 
        CHECK_RESULT(g_discovered, false, "service_discovered_cb");
 
-       wifi_aware_session_stop(session);
-       wifi_aware_session_destroy(session);
-       wifi_aware_subscribe_destroy(subscribe_config);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_subscribe_destroy(g_subscribe_config);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_set_service_discovered_cb_n1)
@@ -693,47 +639,44 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_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");
+       ret = wifi_aware_session_set_service_discovered_cb(g_session, __discovered_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_session_set_service_discovered_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_set_service_discovered_cb(g_session, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_set_service_discovered_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
+       wifi_aware_session_set_service_discovered_cb(g_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");
+       ret = wifi_aware_session_unset_service_discovered_cb(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_unset_service_discovered_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_unset_service_discovered_cb_n)
@@ -741,22 +684,21 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_send_message(g_session, NULL, message, 7, __send_reply, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_send_message");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_send_message_n2)
@@ -766,20 +708,19 @@ TEST_F(WifiAwareSession, wifi_aware_session_send_message_n2)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_set_message_received_cb(g_session, WifiAwareSession::__received_cb, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_set_message_received_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_set_message_received_cb_n1)
@@ -787,34 +728,32 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_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");
+       ret = wifi_aware_session_set_message_received_cb(g_session, NULL, NULL);
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_set_message_received_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_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);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_SUBSCRIBE, &g_session);
+       wifi_aware_session_set_message_received_cb(g_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");
+       ret = wifi_aware_session_unset_message_received_cb(g_session);
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_session_unset_message_received_cb");
 
-       wifi_aware_session_destroy(session);
+       wifi_aware_session_destroy(g_session);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_session_unset_message_received_cb_n)
@@ -822,20 +761,17 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_session_unset_message_received_cb");
 }
 
 TEST_F(WifiAwareSession, wifi_aware_message_received_cb_p)
 {
-       wifi_aware_publish_h publish_config;
-       wifi_aware_session_h session;
-
-       wifi_aware_publish_create(&publish_config);
-       wifi_aware_publish_set_service_name(publish_config, SERVICE_NAME);
-       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL);
-       wifi_aware_session_publish(session, publish_config, WifiAwareSession::__published_cb, NULL);
+       wifi_aware_session_set_message_received_cb(g_session, WifiAwareSession::__received_cb, NULL);
+       wifi_aware_session_publish(g_session, g_publish_config, WifiAwareSession::__published_cb, NULL);
        RUN_GMAIN_LOOP;
 
        wifi_aware_mock_emit_gdbus_signal(MESSAGE_RECEIVED);
@@ -843,29 +779,26 @@ TEST_F(WifiAwareSession, wifi_aware_message_received_cb_p)
 
        CHECK_RESULT(g_message_received, true, "message_received_cb");
 
-       wifi_aware_session_stop(session);
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }
 
 TEST_F(WifiAwareSession, wifi_aware_message_received_cb_n)
 {
-       wifi_aware_publish_h publish_config;
-       wifi_aware_session_h session;
-
-       wifi_aware_publish_create(&publish_config);
-       wifi_aware_publish_set_service_name(publish_config, SERVICE_NAME);
-       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &session);
+       wifi_aware_publish_create(&g_publish_config);
+       wifi_aware_publish_set_service_name(g_publish_config, SERVICE_NAME);
+       wifi_aware_session_create(WIFI_AWARE_SESSION_PUBLISH, &g_session);
 
-       wifi_aware_session_set_message_received_cb(session, WifiAwareSession::__received_cb, NULL);
-       wifi_aware_session_publish(session, publish_config, WifiAwareSession::__published_cb, NULL);
+       wifi_aware_session_set_message_received_cb(g_session, WifiAwareSession::__received_cb, NULL);
+       wifi_aware_session_publish(g_session, g_publish_config, WifiAwareSession::__published_cb, NULL);
        RUN_GMAIN_LOOP;
 
        RUN_GMAIN_LOOP;
 
-       CHECK_RESULT(g_message_received, false, "message_received_cb");
+       CHECK_RESULT(false, g_message_received, "message_received_cb");
 
-       wifi_aware_session_stop(session);
-       wifi_aware_session_destroy(session);
-       wifi_aware_publish_destroy(publish_config);
+       wifi_aware_session_stop(g_session);
+       wifi_aware_session_destroy(g_session);
+       wifi_aware_publish_destroy(g_publish_config);
 }

diff --git a/tests/unittest/wifi-aware-subscribe-unittest-fixture.h b/tests/unittest/wifi-aware-subscribe-unittest-fixture.h
index f5d1132..0978bf4 100644 (file)
--- a/tests/unittest/wifi-aware-subscribe-unittest-fixture.h
+++ b/tests/unittest/wifi-aware-subscribe-unittest-fixture.h
@@ -18,8 +18,6 @@
 
 #include "wifi-aware-unittest-fixture.h"
 
-wifi_aware_subscribe_h g_subscribe_config = NULL;
-
 class WifiAwareSubscribe : public WifiAware
 {
 protected:
@@ -34,5 +32,7 @@ protected:
                wifi_aware_subscribe_destroy(g_subscribe_config);
                WifiAware::TearDown();
        }
+
+       wifi_aware_subscribe_h g_subscribe_config;
 };
 

diff --git a/tests/unittest/wifi-aware-subscribe-unittest.cpp b/tests/unittest/wifi-aware-subscribe-unittest.cpp
index 2ab26fe..b7b3307 100644 (file)
--- a/tests/unittest/wifi-aware-subscribe-unittest.cpp
+++ b/tests/unittest/wifi-aware-subscribe-unittest.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <gtest/gtest.h>
 
 #include "wifi-aware-subscribe-unittest-fixture.h"
@@ -26,7 +25,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_create_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_create");
 
        wifi_aware_subscribe_destroy(subscribe_config);
 }
@@ -36,7 +35,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_create");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_destroy_p)
@@ -47,7 +46,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_destroy_p)
        wifi_aware_subscribe_create(&subscribe_config);
 
        ret = wifi_aware_subscribe_destroy(subscribe_config);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_subscribe_destroy");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_destroy");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_destroy_n)
@@ -55,7 +54,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_destroy");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_ttl_p)
@@ -63,7 +62,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_ttl");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_ttl_n)
@@ -71,7 +70,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_ttl");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_p)
@@ -79,10 +78,10 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_type");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_n1)
@@ -90,7 +89,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_type");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_type_n2)
@@ -98,7 +97,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_type");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_name_p)
@@ -106,7 +105,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_service_name");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_name_n)
@@ -114,7 +113,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_service_name");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_p)
@@ -124,7 +123,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_service_specific_info");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_n)
@@ -134,7 +133,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_service_specific_info_n)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_service_specific_info");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_p)
@@ -144,7 +143,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_p)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_match_filter");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_n)
@@ -154,7 +153,7 @@ TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_match_filter_n)
        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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_match_filter");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_p)
@@ -162,7 +161,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_max_distance");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_n1)
@@ -170,7 +169,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_max_distance");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_max_distance_n2)
@@ -178,7 +177,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_max_distance");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_p)
@@ -186,7 +185,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_subscribe_set_min_distance");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_n1)
@@ -194,7 +193,7 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "wifi_aware_subscribe_set_min_distance");
 }
 
 TEST_F(WifiAwareSubscribe, wifi_aware_subscribe_set_min_distance_n2)
@@ -202,5 +201,5 @@ 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");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_PARAMETER, ret, "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 9f2fe96..d8c2469 100644 (file)
--- a/tests/unittest/wifi-aware-unittest-fixture.h
+++ b/tests/unittest/wifi-aware-unittest-fixture.h
@@ -22,8 +22,6 @@
 #include "wifi-aware.h"
 #include "wifi-aware-unittest-util.h"
 
-#define WIFI_AWARE_FEATURE "http://tizen.org/feature/network.wifi.aware"
-
 class WifiAware : public ::testing::Test
 {
 protected:

diff --git a/tests/unittest/wifi-aware-unittest-util.cpp b/tests/unittest/wifi-aware-unittest-util.cpp
index 96fcea1..531a0c6 100644 (file)
--- a/tests/unittest/wifi-aware-unittest-util.cpp
+++ b/tests/unittest/wifi-aware-unittest-util.cpp
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+#include <stdint.h>
+#include <stdio.h>
+
 #include "wifi-aware-unittest-util.h"
 
 const char *_convert_error_to_string(wifi_aware_error_e error)
@@ -51,3 +54,110 @@ const char *_convert_error_to_string(wifi_aware_error_e error)
                return "UNKNOWN";
        }
 }
+
+typedef struct {
+       unsigned int id;
+       unsigned char mac[MAC_ADDR_LEN];
+} __wifi_aware_peer_s;
+
+typedef struct {
+       uint16_t pub_sub_id;
+       wifi_aware_session_type_e session_type;
+       wifi_aware_publish_h publish_config;
+       wifi_aware_subscribe_h subscribe_config;
+       bool is_requested;
+
+       wifi_aware_published_cb published_cb;
+       void *published_cb_data;
+
+       wifi_aware_subscribed_cb subscribed_cb;
+       void *subscribed_cb_data;
+
+       wifi_aware_service_discovered_cb discovered_cb;
+       void *discovered_cb_data;
+       guint discovered_signal_id;
+
+       wifi_aware_send_message_result_cb send_cb;
+       void *send_cb_data;
+
+       wifi_aware_message_received_cb received_cb;
+       void *received_cb_data;
+       guint received_signal_id;
+
+       wifi_aware_session_terminated_cb terminated_cb;
+       void *terminated_cb_data;
+       guint terminated_signal_id;
+} __wifi_aware_session_s;
+
+typedef struct {
+       uint32_t ndp_id;
+
+       wifi_aware_session_h session;
+       wifi_aware_peer_h peer;
+
+       int role;
+       wifi_aware_security_type_e security_type;
+       char psk[MAX_PSK_LEN + 1];
+       unsigned char pmk[PMK_LEN];
+       size_t pmk_len;
+       int port;
+
+       char iface_name[IFNAMSIZ + 1];
+
+       int peer_port;
+       char peer_ip[IPV6_ADDR_STR_LEN + 1];
+
+       wifi_aware_data_path_open_cb open_cb;
+       void *open_cb_user_data;
+       wifi_aware_data_path_terminated_cb terminated_cb;
+       void *terminated_cb_user_data;
+       guint terminated_signal_id;
+
+       guint ndp_confirmed_signal_id;
+
+       bool is_open;
+} __wifi_aware_data_path_s;
+
+wifi_aware_session_h __create_dummy_session(wifi_aware_session_type_e type)
+{
+       __wifi_aware_session_s *session =
+               (__wifi_aware_session_s *)g_try_malloc0(sizeof(__wifi_aware_session_s));
+       session->pub_sub_id = 1;
+       session->session_type = type;
+       return session;
+}
+
+void __destroy_dummy_session(wifi_aware_session_h session)
+{
+       g_free(session);
+}
+
+wifi_aware_peer_h __create_dummy_peer()
+{
+       __wifi_aware_peer_s *peer = (__wifi_aware_peer_s *)g_try_malloc0(sizeof(__wifi_aware_peer_s));
+       peer->id = 1;
+       memset(peer->mac, sizeof(unsigned char), MAC_ADDR_LEN);
+       return peer;
+}
+
+void __destroy_dummy_peer(wifi_aware_peer_h peer)
+{
+       g_free(peer);
+}
+
+wifi_aware_data_path_h __create_dummy_data_path()
+{
+       __wifi_aware_data_path_s *data_path =
+               (__wifi_aware_data_path_s *)g_try_malloc0(sizeof(__wifi_aware_data_path_s));
+       data_path->ndp_id = 1;
+       data_path->port = DATA_PATH_PEER_PORT;
+       snprintf(data_path->iface_name, IFNAMSIZ, "ndp0");
+       snprintf(data_path->peer_ip, IPV6_ADDR_STR_LEN, "fe80::0");
+       data_path->is_open = true;
+       return data_path;
+}
+
+void __destroy_dummy_data_path(wifi_aware_data_path_h data_path)
+{
+       g_free(data_path);
+}

diff --git a/tests/unittest/wifi-aware-unittest-util.h b/tests/unittest/wifi-aware-unittest-util.h
index e9d398b..2fc1127 100644 (file)
--- a/tests/unittest/wifi-aware-unittest-util.h
+++ b/tests/unittest/wifi-aware-unittest-util.h
@@ -21,13 +21,13 @@
 
 #define CHECK_WIFI_AWARE_SUPPORTED(ret) do { \
                if (!WifiAware::g_wifi_aware_supported) { \
-                       ASSERT_EQ(ret, WIFI_AWARE_ERROR_NOT_SUPPORTED) << "FAIL NOT_SUPPORTED"; \
+                       ASSERT_EQ(WIFI_AWARE_ERROR_NOT_SUPPORTED, ret) << "FAIL NOT_SUPPORTED"; \
                } \
        } while (0)
 
-#define CHECK_RESULT(ret, expected, message) do { \
+#define CHECK_RESULT(expected, ret, message) do { \
                CHECK_WIFI_AWARE_SUPPORTED(ret); \
-               ASSERT_EQ(ret, expected) << "FAIL " << message; \
+               ASSERT_EQ(expected, ret) << "FAIL " << message; \
        } while (0)
 
 #define CALLBACK_TIMEOUT 50
@@ -51,5 +51,19 @@
 #define SERVICE_NAME "NanService"
 #define SERVICE_INFO "ServiceInfo"
 #define MATCH_FILTER "Match Filter"
+#define MAX_PSK_LEN 63
+#define PMK_LEN 32
+#define DATA_PATH_PEER_PORT 1234
+#define MAC_ADDR_LEN 6
+#define IPV6_ADDR_STR_LEN 39
+#define IFNAMSIZ 16
+
+#define WIFI_AWARE_FEATURE "http://tizen.org/feature/network.wifi.aware"
 
 const char *_convert_error_to_string(wifi_aware_error_e error);
+wifi_aware_peer_h __create_dummy_peer();
+void __destroy_dummy_peer(wifi_aware_peer_h peer);
+wifi_aware_session_h __create_dummy_session(wifi_aware_session_type_e type);
+void __destroy_dummy_session(wifi_aware_session_h session);
+wifi_aware_data_path_h __create_dummy_data_path();
+void __destroy_dummy_data_path(wifi_aware_data_path_h data_path);

diff --git a/tests/unittest/wifi-aware-unittest.cpp b/tests/unittest/wifi-aware-unittest.cpp
index 67779ef..c16e218 100644 (file)
--- a/tests/unittest/wifi-aware-unittest.cpp
+++ b/tests/unittest/wifi-aware-unittest.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <gtest/gtest.h>
 
 #include "wifi-aware-unittest-fixture.h"
@@ -57,21 +56,21 @@ TEST_F(WifiAware, wifi_aware_initialize_p)
        wifi_aware_deinitialize();
 
        ret = wifi_aware_initialize();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_initialize");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_initialize");
 }
 
 TEST_F(WifiAware, wifi_aware_initialize_n)
 {
        int ret = 0;
        ret = wifi_aware_initialize();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_ALREADY_INITIALIZED, "wifi_aware_initialize");
+       CHECK_RESULT(WIFI_AWARE_ERROR_ALREADY_INITIALIZED, ret, "wifi_aware_initialize");
 }
 
 TEST_F(WifiAware, wifi_aware_deinitialize_p)
 {
        int ret = 0;
        ret = wifi_aware_deinitialize();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_deinitialize");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_deinitialize");
 }
 
 TEST_F(WifiAware, wifi_aware_deinitialize_n)
@@ -80,7 +79,7 @@ TEST_F(WifiAware, wifi_aware_deinitialize_n)
        wifi_aware_deinitialize();
 
        ret = wifi_aware_deinitialize();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NOT_INITIALIZED, "wifi_aware_deinitialize");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NOT_INITIALIZED, ret, "wifi_aware_deinitialize");
 }
 
 TEST_F(WifiAware, wifi_aware_enable_p)
@@ -88,7 +87,7 @@ TEST_F(WifiAware, wifi_aware_enable_p)
        int ret = 0;
 
        ret = wifi_aware_enable(WifiAware::__enabled_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_enable");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_enable");
 
        RUN_GMAIN_LOOP;
 
@@ -105,7 +104,7 @@ TEST_F(WifiAware, wifi_aware_enable_n)
        RUN_GMAIN_LOOP;
 
        ret = wifi_aware_enable(__enabled_cb, NULL);
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_ALREADY_ENABLED, "wifi_aware_enable");
+       CHECK_RESULT(WIFI_AWARE_ERROR_ALREADY_ENABLED, ret, "wifi_aware_enable");
 
        wifi_aware_disable();
 }
@@ -118,7 +117,7 @@ TEST_F(WifiAware, wifi_aware_disable_p)
        RUN_GMAIN_LOOP;
 
        ret = wifi_aware_disable();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_NONE, "wifi_aware_disable");
+       CHECK_RESULT(WIFI_AWARE_ERROR_NONE, ret, "wifi_aware_disable");
 
        wifi_aware_disable();
 }
@@ -128,5 +127,5 @@ TEST_F(WifiAware, wifi_aware_disable_n)
        int ret = 0;
 
        ret = wifi_aware_disable();
-       CHECK_RESULT(ret, WIFI_AWARE_ERROR_INVALID_OPERATION, "wifi_aware_disable");
+       CHECK_RESULT(WIFI_AWARE_ERROR_INVALID_OPERATION, ret, "wifi_aware_disable");
 }