From: Nishant Chaprana <n.chaprana@samsung.com>
Date: Fri, 11 Jun 2021 06:30:46 +0000 (+0530)
Subject: Fix gtests test cases for AP operations
X-Git-Tag: submit/tizen/20210615.081101~1
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F53%2F259753%2F2;p=platform%2Fcore%2Fapi%2Fwifi-manager.git

Fix gtests test cases for AP operations

Change-Id: I97592a3399f30d2a6163caaba6c08cd0d60ec1e8
Signed-off-by: Nishant Chaprana <n.chaprana@samsung.com>
---

diff --git a/tests/gtest-wifi-manager-ap.cpp b/tests/gtest-wifi-manager-ap.cpp
index 47f29d8..be53fa1 100644
--- a/tests/gtest-wifi-manager-ap.cpp
+++ b/tests/gtest-wifi-manager-ap.cpp
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) 2021 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.
-*/
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include<stdio.h>
 #include <gtest/gtest.h>
@@ -30,43 +30,43 @@ extern "C" {
 static int g_nCallbackRet = WIFI_MANAGER_ERROR_NONE;
 
 class UtcWifiManagerAp : public ::testing::Test {
-        protected:
-                wifi_manager_h handle;
-                WifiManagerTestUtil testUtil;
-
-                UtcWifiManagerAp() : handle(nullptr)
-                {
-                }
-
-                void SetUp() override
-                {
-                        mock_set_system_info_result(true);
-                        mock_set_memory_result(true);
-                        mock_set_gdbus_result(true);
-                        mock_set_vconf_result(true);
-                        wifi_manager_initialize(&handle);
-                        mock_set_gdbus_tech_state("wlan0", true, false);
-                }
-
-                void TearDown() override
-                {
-                        wifi_manager_deinitialize(handle);
-                        mock_set_system_info_result(false);
-                        mock_set_memory_result(false);
-                        mock_set_gdbus_result(false);
-                        mock_set_vconf_result(false);
-                        mock_set_gdbus_tech_state("wlan0", false, false);
-                        g_nCallbackRet = WIFI_MANAGER_ERROR_NONE;
-                }
+protected:
+	wifi_manager_h handle;
+	wifi_manager_ap_h ap_h;
+	WifiManagerTestUtil testUtil;
+	const char *essid;
+	wifi_manager_address_family_e family;
+	wifi_manager_ip_config_type_e type;
+
+	UtcWifiManagerAp() : handle(nullptr), ap_h(nullptr), essid("test_essid"), family(WIFI_MANAGER_ADDRESS_FAMILY_IPV4), type(WIFI_MANAGER_IP_CONFIG_TYPE_NONE)
+	{
+	}
+
+	void SetUp() override
+	{
+		mock_set_system_info_result(true);
+		mock_set_memory_result(true);
+		mock_set_gdbus_result(true);
+		mock_set_vconf_result(true);
+		wifi_manager_initialize(&handle);
+		wifi_manager_ap_create(handle, essid, &ap_h);
+		mock_set_gdbus_tech_state("wlan0", true, false);
+	}
+
+	void TearDown() override
+	{
+		wifi_manager_ap_destroy(ap_h);
+		wifi_manager_deinitialize(handle);
+		mock_set_system_info_result(false);
+		mock_set_memory_result(false);
+		mock_set_gdbus_result(false);
+		mock_set_vconf_result(false);
+		mock_set_gdbus_tech_state("wlan0", false, false);
+		g_nCallbackRet = WIFI_MANAGER_ERROR_NONE;
+	}
 };
 
-
-bool callback(unsigned char *vsie, int length, void *user_data)
-{
-	return true;
-}
-
-bool vsie_cb (unsigned char *vsie, int length, void *user_data)
+bool vsie_cb(unsigned char *vsie, int length, void *user_data)
 {
 	return true;
 }
@@ -81,550 +81,659 @@ bool ipv6_cb(char *ipv6_address, void *user_data)
 	return true;
 }
 
-wifi_manager_ap_h _ap;
-
-wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-
-wifi_manager_ip_config_type_e type;
-
-const char essid = '1';
-
 TEST_F(UtcWifiManagerAp, ApCreateN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(nullptr, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(nullptr, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApCreateN2)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(handle, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(handle, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApCreateN3)
 {
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(handle, &essid, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_create(handle, essid, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApCreateP1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_create(handle, &essid, &_ap));
+	wifi_manager_ap_h _ap;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_create(handle, essid, &_ap));
+	wifi_manager_ap_destroy(_ap);
 }
 
 TEST_F(UtcWifiManagerAp, ApHiddenCreateN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(nullptr, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(handle, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(nullptr, essid, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(nullptr, nullptr, &ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(handle, essid, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(nullptr, essid, &ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(handle, nullptr, &ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(nullptr, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApHiddenCreateN2)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(handle, nullptr, nullptr));
+	wifi_manager_ap_destroy(ap_h);
+	wifi_manager_deinitialize(handle);
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_INITIALIZED, wifi_manager_ap_hidden_create(handle, essid, &ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_INITIALIZED, wifi_manager_ap_hidden_create(handle, nullptr, &ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_INITIALIZED, wifi_manager_ap_hidden_create(handle, essid, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_INITIALIZED, wifi_manager_ap_hidden_create(handle, nullptr, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApHiddenCreateN3)
+TEST_F(UtcWifiManagerAp, ApHiddenCreateP1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_hidden_create(handle, &essid, nullptr));
+	wifi_manager_ap_h _ap;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_hidden_create(handle, essid, &_ap));
+	wifi_manager_ap_destroy(_ap);
 }
 
-TEST_F(UtcWifiManagerAp, ApHiddenCreateP1)
+TEST_F(UtcWifiManagerAp, ApDestroyP1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_hidden_create(handle, &essid, &_ap));
+	wifi_manager_ap_h _ap;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_create(handle, essid, &_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_destroy(_ap));
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_hidden_create(handle, essid, &_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_destroy(_ap));
 }
 
 TEST_F(UtcWifiManagerAp, ApDestroyN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_destroy(nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_destroy(nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApCloneN1)
+TEST_F(UtcWifiManagerAp, ApCloneP1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_clone(nullptr, _ap));
+	wifi_manager_ap_h _ap;
+	wifi_manager_ap_h _clone_ap;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_create(handle, essid, &_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_clone(&_clone_ap, _ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_destroy(_clone_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_destroy(_ap));
 }
 
-TEST_F(UtcWifiManagerAp, ApCloneN2)
+TEST_F(UtcWifiManagerAp, ApCloneN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_clone(nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_clone(nullptr, ap_h));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_clone(&ap_h, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_clone(nullptr, nullptr));
 }
 
 /*
- * TEST_F(UtcWifiManagerAp, ApRefreshP1)
+TEST_F(UtcWifiManagerAp, ApRefreshP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_refresh(_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_refresh(ap_h));
 }
 */
 
 TEST_F(UtcWifiManagerAp, ApRefreshN1)
 {
-        wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_refresh(_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_refresh(ap_h));
 }
 
 TEST_F(UtcWifiManagerAp, ApRefreshN2)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_refresh(nullptr));
-}
-
-TEST_F(UtcWifiManagerAp, ApRefreshN3)
-{
-	wifi_manager_get_connected_ap(handle, &_ap);
-	mock_set_gdbus_error_msg(ERROR_PERMISSION_DENIED);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_PERMISSION_DENIED, wifi_manager_ap_refresh(_ap));
-}
-
-TEST_F(UtcWifiManagerAp, ApRefreshN4)
-{
-        mock_set_gdbus_error_msg(ERROR_NULL);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_refresh(_ap));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_refresh(nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEssidN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_essid(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_essid(ap_h, nullptr));
 	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_essid(nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetRawSsidN1)
 {
 	int *len = NULL;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_raw_ssid(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_raw_ssid(ap_h, nullptr, nullptr));
 	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_raw_ssid(nullptr, nullptr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_raw_ssid(_ap, nullptr, len));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_raw_ssid(ap_h, nullptr, len));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetBssidN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_bssid(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_bssid(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetRssiN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_rssi(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_rssi(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetRssiLevelN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_rssi_level(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_rssi_level(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetFrequencyN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_frequency(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_frequency(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApForeachVsieN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_foreach_vsie(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_foreach_vsie(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApForeachVsieP1)
 {
-        wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_foreach_vsie(_ap, vsie_cb, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_foreach_vsie(ap_h, vsie_cb, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetMaxSpeedN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_max_speed(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_max_speed(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApIsFavoriteN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_favorite(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_favorite(ap_h, nullptr));
 }
 
 
 TEST_F(UtcWifiManagerAp, ApIsPasspointN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_passpoint(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_passpoint(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetConnectionStateN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_connection_state(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_connection_state(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetIpConfigTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_ip_config_type(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_ip_config_type(ap_h, family, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetIpConfigTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_config_type(nullptr, addr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_config_type(nullptr, family, type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetIpConfigTypeP1)
 {
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_ip_config_type_e type = WIFI_MANAGER_IP_CONFIG_TYPE_NONE;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_config_type(_ap, addr, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_config_type(_ap, addr, &type));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_config_type(_ap, addr, type));
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_config_type(_ap, addr, &type));
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_config_type(ap_h, family, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_config_type(ap_h, family, &type));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_config_type(ap_h, family, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_config_type(ap_h, family, &type));
+}
+
+TEST_F(UtcWifiManagerAp, ApGetIpAddressP1)
+{
+	const char *correct_ip = "::1";
+	char *ip_addr;
+
+	type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, correct_ip));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_address(ap_h, family, &ip_addr));
+	free(ip_addr);
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	correct_ip = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, correct_ip));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_address(ap_h, family, &ip_addr));
+	free(ip_addr);
 }
 
 TEST_F(UtcWifiManagerAp, ApGetIpAddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_ip_address(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_ip_address(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_ip_address(nullptr, family, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetIpAddressN2)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
 	char *ip_address;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NO_CONNECTION, wifi_manager_ap_get_ip_address(_ap, addr, &ip_address));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NO_CONNECTION, wifi_manager_ap_get_ip_address(ap_h, family, &ip_address));
+}
+
+TEST_F(UtcWifiManagerAp, ApSetIpAddressP1)
+{
+	const char *correct_ip = "::1";
+
+	type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, correct_ip));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	correct_ip = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(ap_h, family, correct_ip));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetIpAddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(_ap, addr, nullptr));
+	const char *correct_ip = "::1";
+	const char *invalid_ip = "invalid_ip";
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(nullptr, family, correct_ip));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(ap_h, family, invalid_ip));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	correct_ip = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(nullptr, family, correct_ip));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(ap_h, family, invalid_ip));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetIpAddressP1)
+TEST_F(UtcWifiManagerAp, ApGetSubnetMaskP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-	char ip = '1';
-	char *ip_addr = &ip;
-	const char *ip_address = &ip;
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(_ap, addr, ip_address));
-	EXPECT_EQ(-30277630, wifi_manager_ap_get_ip_address(_ap, addr, &ip_addr));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_ip_address(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_ip_address(_ap, addr, &ip_addr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_ip_address(_ap, addr, ip_address));
+	char *subnet;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(ap_h, family, &subnet));
+	free(subnet);
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(ap_h, family, &subnet));
+	free(subnet);
 }
 
 TEST_F(UtcWifiManagerAp, ApGetSubnetMaskN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_subnet_mask(_ap, addr, nullptr));
+	char *subnet;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_subnet_mask(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_subnet_mask(nullptr, family, &subnet));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_subnet_mask(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_subnet_mask(nullptr, family, &subnet));
+}
+
+TEST_F(UtcWifiManagerAp, ApSetSubnetMaskP1)
+{
+	char *subnet;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_subnet_mask(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(ap_h, family, &subnet));
+	free(subnet);
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_subnet_mask(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(ap_h, family, &subnet));
+	free(subnet);
 }
 
 TEST_F(UtcWifiManagerAp, ApSetSubnetMaskN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_subnet_mask(_ap, addr, nullptr));
+	const char *invalid_subnet = "invalid_subnet";
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_subnet_mask(ap_h, family, invalid_subnet));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_subnet_mask(ap_h, family, invalid_subnet));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetSubnetMaskP1)
+TEST_F(UtcWifiManagerAp, ApSetPrefixLengthP1)
 {
-	const char mask = '1';
-	char *subnet;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_subnet_mask(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(_ap, addr, &subnet));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_subnet_mask(_ap, addr, &mask));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_subnet_mask(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_subnet_mask(_ap, addr, &subnet));
+	int prefix_len = 24;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_prefix_length(ap_h, family, prefix_len));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_prefix_length(ap_h, family, &prefix_len));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_prefix_length(ap_h, family, prefix_len));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_prefix_length(ap_h, family, &prefix_len));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetPrefixLengthN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_prefix_length(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_prefix_length(ap_h, family, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetPrefixLengthN1)
 {
 	int prefix_len = 1;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_prefix_length(nullptr, addr, prefix_len));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_prefix_length(nullptr, family, prefix_len));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetPrefixLengthP1)
+TEST_F(UtcWifiManagerAp, ApGetGatewayAddressN1)
 {
-        int prefix_len = 1;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_prefix_length(_ap, addr, prefix_len));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_prefix_length(_ap, addr, &prefix_len));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_prefix_length(_ap, addr, prefix_len));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_prefix_length(_ap, addr, &prefix_len));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_gateway_address(ap_h, family, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApGetGatewayAddressN1)
+TEST_F(UtcWifiManagerAp, ApSetGatewayAddressP1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_gateway_address(_ap, addr, nullptr));
+	const char* correct_gw = "::1";
+	char *gw_addr;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_gateway_address(ap_h, family, &gw_addr));
+	free(gw_addr);
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(ap_h, family, correct_gw));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_gateway_address(ap_h, family, &gw_addr));
+	free(gw_addr);
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	correct_gw = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_gateway_address(ap_h, family, &gw_addr));
+	free(gw_addr);
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(ap_h, family, correct_gw));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_gateway_address(ap_h, family, &gw_addr));
+	free(gw_addr);
 }
 
 TEST_F(UtcWifiManagerAp, ApSetGatewayAddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(_ap, addr, nullptr));
+	const char* correct_gw = "::1";
+	const char* invalid_gw = "invalid_gw_addr";
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(nullptr, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(nullptr, family, correct_gw));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(ap_h, family, invalid_gw));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	correct_gw = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(nullptr, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(nullptr, family, correct_gw));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(ap_h, family, invalid_gw));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetGatewayAddressP1)
+TEST_F(UtcWifiManagerAp, ApGetDhcpServerAddressP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	const char g_addr = '1';
-	char g_ad = '1';
-	char *ad = &g_ad;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_gateway_address(_ap, addr, &ad));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(_ap, addr, &g_addr));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_gateway_address(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_gateway_address(_ap, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_gateway_address(_ap, addr, &g_addr));
+	char *dhcp_server;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dhcp_server_address(ap_h, family, &dhcp_server));
+	free(dhcp_server);
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDhcpServerAddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dhcp_server_address(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dhcp_server_address(ap_h, family, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApGetDhcpServerAddressP1)
+TEST_F(UtcWifiManagerAp, ApGetDhcpServerAddressN2)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	char dhcp = '1';
-	char *dp = &dhcp;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dhcp_server_address(_ap, addr, &dp));
+	char *dhcp_server;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_SUPPORTED, wifi_manager_ap_get_dhcp_server_address(ap_h, family, &dhcp_server));
 }
 
-TEST_F(UtcWifiManagerAp, ApGetDhcpServerAddressN2)
+TEST_F(UtcWifiManagerAp, ApGetDhcpLeaseDurationP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	char dhcp = '1';
-	char *dp = &dhcp;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_SUPPORTED, wifi_manager_ap_get_dhcp_server_address(_ap, addr, &dp));
+	int dhcp_lease;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dhcp_lease_duration(ap_h, family, &dhcp_lease));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDhcpLeaseDurationN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dhcp_lease_duration(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dhcp_lease_duration(ap_h, family, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApGetDhcpLeaseDurationP1)
+TEST_F(UtcWifiManagerAp, ApGetDhcpLeaseDurationN2)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	int dhcp = 1;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dhcp_lease_duration(_ap, addr, &dhcp));
+	int dhcp;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_SUPPORTED, wifi_manager_ap_get_dhcp_lease_duration(ap_h, family, &dhcp));
 }
 
-TEST_F(UtcWifiManagerAp, ApGetDhcpLeaseDurationN2)
+TEST_F(UtcWifiManagerAp, ApGetProxyAddressP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-        int dhcp = 1;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NOT_SUPPORTED, wifi_manager_ap_get_dhcp_lease_duration(_ap, addr, &dhcp));
+	const char *proxy = "192.168.1.1";
+	char *proxy_addr;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_proxy_address(ap_h, family, proxy));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_proxy_address(ap_h, family, &proxy_addr));
+	free(proxy_addr);
 }
 
 TEST_F(UtcWifiManagerAp, ApGetProxyAddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_proxy_address(_ap, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_proxy_address(ap_h, family, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetProxyAddressN1)
+TEST_F(UtcWifiManagerAp, ApSetProxyAddressP1)
 {
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_proxy_address(_ap, addr, nullptr));
+	const char *proxy = "192.168.1.1";
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_proxy_address(ap_h, family, proxy));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetProxyAddressP1)
+TEST_F(UtcWifiManagerAp, ApSetProxyAddressN1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-	const char add = '1';
-	char ad = '1';
-	char *a = &ad;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_proxy_address(_ap, addr, &add));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_proxy_address(_ap, addr, &a));
+	const char *proxy = "192.168.1.1";
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_proxy_address(nullptr, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_proxy_address(nullptr, family, proxy));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetProxyTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_proxy_type(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_proxy_type(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetProxyTypeN1)
 {
 	wifi_manager_proxy_type_e type = WIFI_MANAGER_PROXY_TYPE_DIRECT;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_proxy_type(nullptr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_proxy_type(nullptr, type));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDnsConfigTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_config_type(_ap, addr, nullptr));
+	wifi_manager_dns_config_type_e dns_type;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_config_type(ap_h, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_config_type(nullptr, family, &dns_type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetDnsConfigTypeN1)
 {
-	wifi_manager_dns_config_type_e type = WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_config_type(nullptr, addr, type));
+	wifi_manager_dns_config_type_e dns_type = WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_config_type(nullptr, family, dns_type));
+
+	dns_type = WIFI_MANAGER_DNS_CONFIG_TYPE_NONE;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_config_type(ap_h, family, dns_type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetDnsConfigTypeP1)
 {
-	wifi_manager_dns_config_type_e type = WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_config_type(_ap, addr, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dns_config_type(_ap, addr, &type));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_config_type(_ap, addr, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dns_config_type(_ap, addr, &type));
+	wifi_manager_dns_config_type_e dns_type = WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC;
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_config_type(ap_h, family, dns_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dns_config_type(ap_h, family, &dns_type));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_config_type(ap_h, family, dns_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_dns_config_type(ap_h, family, &dns_type));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDnsAddressN1)
 {
 	int order = 1;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_address(_ap, order, addr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_address(ap_h, order, family, nullptr));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetDnsAddressN1)
+TEST_F(UtcWifiManagerAp, ApSetDnsAddressP1)
 {
 	int order = 1;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(_ap, order, addr, nullptr));
-}
+	const char *dns_addr = "::";
 
-TEST_F(UtcWifiManagerAp, ApSetDnsAddressP1)
-{
-        int order = 1;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	wifi_manager_address_family_e addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
-	const char ad = '1';
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(_ap, order, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(_ap, order, addr, &ad));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_address(_ap, order, addr, nullptr));
-	addr = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(_ap, order, addr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(_ap, order, addr,&ad));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_dns_address(_ap, order, addr, nullptr));
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(ap_h, order, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(ap_h, order, family, dns_addr));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	dns_addr = "192.168.1.1";
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(ap_h, order, family, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_dns_address(ap_h, order, family, dns_addr));
 }
 
-TEST_F(UtcWifiManagerAp, ApSetDnsAddressN2)
+TEST_F(UtcWifiManagerAp, ApSetDnsAddressN1)
 {
-        int order = 0;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(_ap, order, addr, nullptr));
+	int order = 1;
+	const char *invalid_dns_addr = "invalid_dns_addr";
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV6;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(ap_h, order, family, invalid_dns_addr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(nullptr, order, family, invalid_dns_addr));
+	order = 0;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(ap_h, order, family, nullptr));
+
+	family = WIFI_MANAGER_ADDRESS_FAMILY_IPV4;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(ap_h, order, family, invalid_dns_addr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(nullptr, order, family, invalid_dns_addr));
+	order = 0;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_dns_address(ap_h, order, family, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetCountryCodeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_countrycode(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_countrycode(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ForeachFoundBssidN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_foreach_found_bssid(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_foreach_found_bssid(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ForeachFoundBssidP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_foreach_found_bssid(_ap, found_bssid_cb, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_foreach_found_bssid(ap_h, found_bssid_cb, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetSecurityTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_security_type(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_security_type(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetSecurityTypeN1)
 {
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_NONE;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_security_type(nullptr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_security_type(nullptr, type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetSecurityTypeP1)
 {
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_NONE;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_security_type(_ap, &type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_security_type(ap_h, &type));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEncryptionTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_encryption_type(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_encryption_type(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEncryptionTypeN1)
 {
 	wifi_manager_encryption_type_e type = WIFI_MANAGER_ENCRYPTION_TYPE_NONE;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_encryption_type(nullptr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_encryption_type(nullptr, type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEncryptionTypeP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_encryption_type_e type = WIFI_MANAGER_ENCRYPTION_TYPE_NONE;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_encryption_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_encryption_type(_ap, &type));
+	wifi_manager_encryption_type_e type = WIFI_MANAGER_ENCRYPTION_TYPE_NONE;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_encryption_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_encryption_type(ap_h, &type));
+}
+
+TEST_F(UtcWifiManagerAp, ApIsPassphraseRequiredP1)
+{
+	bool required;
+	wifi_manager_security_type_e security_type = WIFI_MANAGER_SECURITY_TYPE_WEP;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, security_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_passphrase_required(ap_h, &required));
+	EXPECT_EQ(TRUE, required);
 }
 
 TEST_F(UtcWifiManagerAp, ApIsPassphraseRequiredN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_passphrase_required(_ap, nullptr));
+	bool required;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_passphrase_required(ap_h, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_passphrase_required(nullptr, &required));
 }
 
-TEST_F(UtcWifiManagerAp, ApIsPassphraseRequiredP1)
+TEST_F(UtcWifiManagerAp, ApSetPassphraseP1)
 {
-	bool required = true;
-	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_WEP;
-	const char pass = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
-	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_is_passphrase_required(_ap, &required));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_set_passphrase(_ap, &pass));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_passphrase_required(_ap, &required));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_passphrase(_ap, &pass));
+	const char *passphrase = "dummy_passphrase";
+	wifi_manager_security_type_e security_type = WIFI_MANAGER_SECURITY_TYPE_WEP;
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, security_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_passphrase(ap_h, passphrase));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetPassphraseN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_passphrase(_ap, nullptr));
+	const char *passphrase = "dummy_passphrase";
+
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_passphrase(nullptr, passphrase));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_passphrase(ap_h, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_set_passphrase(ap_h, passphrase));
 }
 
 TEST_F(UtcWifiManagerAp, ApIsWpsSupportedN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_wps_supported(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_wps_supported(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApIsWpsSupportedP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
 	bool support = true;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_wps_supported(_ap, &support));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_wps_supported(ap_h, &support));
 }
 
 TEST_F(UtcWifiManagerAp, ApIsHiddenN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_hidden(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_is_hidden(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApIsHiddenP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
 	bool hidden = true;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_hidden(_ap, &hidden));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_is_hidden(ap_h, &hidden));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapPassphraseN1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
 	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_passphrase(nullptr, nullptr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_passphrase(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_passphrase(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapPassphraseP1)
 {
 	const char username = '1';
 	const char pass = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_passphrase(_ap, &username, &pass));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_passphrase(ap_h, &username, &pass));
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_passphrase(_ap, &username, &pass));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_passphrase(ap_h, &username, &pass));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapPassphraseN1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_passphrase(nullptr, nullptr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_passphrase(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_passphrase(nullptr, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_passphrase(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapPassphraseP1)
@@ -632,253 +741,235 @@ TEST_F(UtcWifiManagerAp, ApGetEapPassphraseP1)
 	char usr = '1';
 	char *username = &usr;
 	bool is_set = true;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_passphrase(_ap, &username, &is_set));
-        wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_passphrase(_ap, &username, &is_set));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_passphrase(ap_h, &username, &is_set));
+	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_passphrase(ap_h, &username, &is_set));
 
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapAnonymousIdentityN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_anonymous_identity(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_anonymous_identity(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapAnonymousIdentityP1)
 {
 	const char name = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_anonymous_identity(_ap, &name));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_anonymous_identity(ap_h, &name));
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_anonymous_identity(_ap, &name));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_anonymous_identity(ap_h, &name));
 }
 
 
 TEST_F(UtcWifiManagerAp, ApGetEapAnonymousIdentityN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_anonymous_identity(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_anonymous_identity(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapAnonymousIdentityP1)
 {
 	char name = '1';
 	char *identity = &name;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_anonymous_identity(_ap, &identity));
-        wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_anonymous_identity(_ap, &identity));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_anonymous_identity(ap_h, &identity));
+	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_anonymous_identity(ap_h, &identity));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapCertFileN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_ca_cert_file(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_ca_cert_file(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapCertFileP1)
 {
 	char name = '1';
 	char *file = &name;
-	wifi_manager_get_connected_ap(handle, &_ap);
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_ca_cert_file(_ap, &file));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_ca_cert_file(_ap, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_ca_cert_file(ap_h, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_ca_cert_file(ap_h, &file));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapCertFileN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_ca_cert_file(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_ca_cert_file(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapCertFileP1)
 {
 	const char file = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_ca_cert_file(_ap, &file));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_ca_cert_file(_ap, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_ca_cert_file(ap_h, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_ca_cert_file(ap_h, &file));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapClientCertFileN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_client_cert_file(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_client_cert_file(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapClientCertFileP1)
 {
 	char name = '1';
 	char *file = &name;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_client_cert_file(_ap, &file));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_client_cert_file(_ap, &file));
+	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_client_cert_file(ap_h, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_client_cert_file(ap_h, &file));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapClientCertFileN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_client_cert_file(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_client_cert_file(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapClientCertFileP1)
 {
 	const char file = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_client_cert_file(_ap, &file));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_client_cert_file(_ap, &file));
+	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_client_cert_file(ap_h, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_client_cert_file(ap_h, &file));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapPrivateKeyFileN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_private_key_file(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_private_key_file(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapPrivateKeyFileP1)
 {
 	char name = '1';
 	char *file = &name;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_private_key_file(_ap, &file));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_private_key_file(_ap, &file));
+	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_private_key_file(ap_h, &file));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_private_key_file(ap_h, &file));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapPrivateKeyInfoN1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_private_key_info(nullptr, nullptr, nullptr));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_private_key_info(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_private_key_info(nullptr, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_private_key_info(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapPrivateKeyInfoP1)
 {
 	const char file = '1';
 	const char pass = '1';
-	wifi_manager_get_connected_ap(handle, &_ap);
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_private_key_info(_ap, &file, &pass));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_private_key_info(_ap, &file, &pass));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_private_key_info(ap_h, &file, &pass));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_private_key_info(ap_h, &file, &pass));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_type(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_type(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapTypeN1)
 {
 	wifi_manager_eap_type_e type = WIFI_MANAGER_EAP_TYPE_PEAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_type(nullptr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_type(nullptr, type));
 }
 
 
 TEST_F(UtcWifiManagerAp, ApSetEapTypeP1)
 {
-        wifi_manager_eap_type_e eap_type = WIFI_MANAGER_EAP_TYPE_PEAP;
-	wifi_manager_get_connected_ap(handle, &_ap);
+	wifi_manager_eap_type_e eap_type = WIFI_MANAGER_EAP_TYPE_PEAP;
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_type(_ap, eap_type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_type(_ap, &eap_type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_type(_ap, eap_type));
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_type(_ap, &eap_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_type(ap_h, eap_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_type(ap_h, &eap_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_type(ap_h, eap_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_type(ap_h, &eap_type));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetEapAuthTypeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_auth_type(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_eap_auth_type(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapAuthTypeN1)
 {
 	wifi_manager_eap_auth_type_e type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_auth_type(nullptr, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_set_eap_auth_type(nullptr, type));
 }
 
 TEST_F(UtcWifiManagerAp, ApSetEapAuthTypeP1)
 {
-        wifi_manager_eap_auth_type_e auth_type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE;
-	wifi_manager_get_connected_ap(handle, &_ap);
+	wifi_manager_eap_auth_type_e auth_type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE;
 	wifi_manager_security_type_e type = WIFI_MANAGER_SECURITY_TYPE_EAP;
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_auth_type(_ap, auth_type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_auth_type(_ap, &auth_type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(_ap, type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_auth_type(_ap, auth_type));
-	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_auth_type(_ap, &auth_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_set_eap_auth_type(ap_h, auth_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_OPERATION, wifi_manager_ap_get_eap_auth_type(ap_h, &auth_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_security_type(ap_h, type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_set_eap_auth_type(ap_h, auth_type));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_eap_auth_type(ap_h, &auth_type));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDisconnectReasonN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_disconnect_reason(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_disconnect_reason(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetDisconnectReasonP1)
 {
 	wifi_manager_disconnect_reason_e dc_reason = WIFI_REASON_UNSPECIFIED;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_disconnect_reason(_ap, &dc_reason));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_disconnect_reason(ap_h, &dc_reason));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetAssocStatusCodeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_assoc_status_code(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_assoc_status_code(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetAssocStatusCodeP1)
 {
 	wifi_manager_assoc_status_code_e status_code = WLAN_STATUS_SUCCESS;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_assoc_status_code(_ap, &status_code));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_assoc_status_code(ap_h, &status_code));
 }
 
 TEST_F(UtcWifiManagerAp, ApForeachIpv6AddressN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_foreach_ipv6_address(_ap, nullptr, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_foreach_ipv6_address(ap_h, nullptr, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApForeachIpv6AddressP1)
 {
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_foreach_ipv6_address(_ap, ipv6_cb, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_foreach_ipv6_address(ap_h, ipv6_cb, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetErrorStateN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_error_state(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_error_state(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetErrorStateP1)
 {
 	wifi_manager_error_e error_state = WIFI_MANAGER_ERROR_NONE;
-	wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_error_state(_ap, &error_state));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_error_state(ap_h, &error_state));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetConnectionModeN1)
 {
-        EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_connection_mode(_ap, nullptr));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_INVALID_PARAMETER, wifi_manager_ap_get_connection_mode(ap_h, nullptr));
 }
 
 TEST_F(UtcWifiManagerAp, ApGetConnectionModeN2)
 {
 	wifi_manager_connection_mode_e mode = WIFI_MANAGER_CONNECTION_MODE_80211_B;
-	wifi_manager_get_connected_ap(handle, &_ap);
-	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_get_connection_mode(_ap, &mode));
+	EXPECT_EQ(WIFI_MANAGER_ERROR_OPERATION_FAILED, wifi_manager_ap_get_connection_mode(ap_h, &mode));
 }
 
 /*
  * TEST_F(UtcWifiManagerAp, ApGetConnectionModeP1)
-{
-	wifi_manager_connection_mode_e mode = WIFI_MANAGER_CONNECTION_MODE_80211_B;
-        wifi_manager_get_connected_ap(handle, &_ap);
-        EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_connection_mode(_ap, &mode));
-}
-*/
+ {
+ wifi_manager_connection_mode_e mode = WIFI_MANAGER_CONNECTION_MODE_80211_B;
+ EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, wifi_manager_ap_get_connection_mode(ap_h, &mode));
+ }
+ */