Fix build issue when building with gcov and gtests flags

Change-Id: Id0d438179847c67cce5f00c83ae3c860744ed305

diff --git a/gtest/gtest.cpp b/gtest/gtest.cpp
index 0385b33..76bc55b 100644 (file)
--- a/gtest/gtest.cpp
+++ b/gtest/gtest.cpp
@@ -42,94 +42,52 @@ static void __network_evt_cb(net_event_info_t* event_cb, void* user_data)
 TEST(LibnetClient, register_p)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_register_client((net_event_cb_t)__network_evt_cb, NULL);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, register_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_register_client(NULL, NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, register_ext_p)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_register_client_ext((net_event_cb_t)__network_evt_cb, NET_DEVICE_DEFAULT, NULL);
-       EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, register_ext_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_register_client_ext(NULL, NET_DEVICE_DEFAULT, NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, power_on_p)
-{
-       MainLoop M;
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_power_on(FALSE);
-       ret = (ret == NET_ERR_NONE || ret == NET_ERR_IN_PROGRESS
-                       || ret == NET_ERR_ALREADY_EXISTS);
-       EXPECT_NE(ret, 0);
-       M.run(5);
-}
-
-TEST(LibnetClient, set_bg_scan_mode_p)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_set_background_scan_mode(WIFI_BGSCAN_MODE_PERIODIC);
-       EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, set_bg_scan_mode_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_set_background_scan_mode(net_wifi_background_scan_mode_t(4));
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, open_connection_with_preference_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_open_connection_with_preference((net_service_type_t)10);
+       ret = net_register_client(NULL, NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
 TEST(LibnetClient, open_connection_with_profile_p)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_open_connection_with_profile(
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_open_connection_with_profile(handle,
                        "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x");
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, close_connection_with_profile_p)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_close_connection(
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_close_connection(handle,
                        "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x");
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, close_connection_with_profile_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_close_connection("gtest");
+       ret = net_close_connection(NULL, "gtest");
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -137,16 +95,20 @@ TEST(LibnetClient, get_wifi_state_p)
 {
        int ret = NET_ERR_NONE;
        net_wifi_state_t state;
+       void *handle = NULL;
 
-       ret = net_get_wifi_state(&state);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_wifi_state(handle, &state);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, get_wifi_state_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_wifi_state(NULL);
+       ret = net_get_wifi_state(NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -154,16 +116,20 @@ TEST(LibnetClient, get_network_status_p)
 {
        int ret = NET_ERR_NONE;
        net_cm_network_status_t status;
+       void *handle = NULL;
 
-       ret = net_get_network_status(NET_DEVICE_WIFI, &status);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_network_status(handle, NET_DEVICE_WIFI, &status);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, get_network_status_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_network_status(NET_DEVICE_WIFI, NULL);
+       ret = net_get_network_status(NULL, NET_DEVICE_WIFI, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -172,18 +138,22 @@ TEST(LibnetClient, net_profile_list_p)
        int ret = NET_ERR_NONE;
        net_profile_info_t *profList;
        int profListCount = 0;
+       void *handle = NULL;
 
-       ret = net_get_profile_list(NET_DEVICE_WIFI, &profList, &profListCount);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
-       ret = net_get_profile_list(NET_DEVICE_ETHERNET, &profList, &profListCount);
+       ret = net_get_profile_list(handle, NET_DEVICE_WIFI, &profList, &profListCount);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_profile_list(handle, NET_DEVICE_ETHERNET, &profList, &profListCount);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_profile_list_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_profile_list(NET_DEVICE_WIFI, NULL, NULL);
+       ret = net_get_profile_list(NULL, NET_DEVICE_WIFI, NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -191,7 +161,7 @@ TEST(LibnetClient, net_get_profile_info_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_profile_info("gtest", NULL);
+       ret = net_get_profile_info(NULL, "gtest", NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -199,7 +169,7 @@ TEST(LibnetClient, net_modify_profile_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_modify_profile("gtest", NULL);
+       ret = net_modify_profile(NULL, "gtest", NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -207,7 +177,7 @@ TEST(LibnetClient, net_delete_profile_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_delete_profile("gtest");
+       ret = net_delete_profile(NULL, "gtest");
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -216,56 +186,12 @@ TEST(LibnetClient, net_add_profile_n)
        MainLoop M;
        int ret = NET_ERR_NONE;
 
-       ret = net_add_profile(NET_SERVICE_INTERNET, NULL);
+       ret = net_add_profile(NULL, NET_SERVICE_INTERNET, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 
        M.run(5);
 }
 
-TEST(LibnetClient, net_open_connection_with_wifi_info_p)
-{
-       int ret = NET_ERR_NONE;
-       net_wifi_connection_info_t wifi_info = {{0, }, };
-       wifi_info.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
-       wifi_info.security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK;
-       strncpy(wifi_info.essid, "gtest", NET_WLAN_ESSID_LEN+1);
-
-       ret = net_open_connection_with_wifi_info(&wifi_info);
-       ret = (ret == NET_ERR_NONE || ret == NET_ERR_IN_PROGRESS);
-       EXPECT_EQ(ret, 0);
-}
-
-TEST(LibnetClient, net_open_connection_with_wifi_info_n)
-{
-       MainLoop M;
-       int ret = NET_ERR_NONE;
-
-       ret = net_open_connection_with_wifi_info(NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-
-       M.run(5);
-}
-
-TEST(LibnetClient, net_wifi_enroll_wps_p)
-{
-       int ret = NET_ERR_NONE;
-       net_wifi_wps_info_t wps_info;
-       memset(&wps_info, 0, sizeof(net_wifi_wps_info_t));
-       wps_info.type = WIFI_WPS_PBC;
-
-       ret = net_wifi_enroll_wps("/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x",
-                       &wps_info);
-       EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_wifi_enroll_wps_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_enroll_wps("gtest", NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
 TEST(LibnetClient, net_check_get_privilege)
 {
        int ret = NET_ERR_NONE;
@@ -278,68 +204,45 @@ TEST(LibnetClient, net_get_tcpdump_state_p)
 {
        int ret = NET_ERR_NONE;
        gboolean is_running;
+       void *handle = NULL;
 
-       ret = net_get_tcpdump_state(&is_running);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_tcpdump_state(handle, &is_running);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_get_tcpdump_state_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_tcpdump_state(NULL);
+       ret = net_get_tcpdump_state(NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
 TEST(LibnetClient, net_start_tcpdump)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_start_tcpdump();
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_stop_tcpdump)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_stop_tcpdump();
+       ret = net_start_tcpdump(handle);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
-TEST(LibnetClient, net_wifi_tdls_connected_peer_p)
+TEST(LibnetClient, net_stop_tcpdump)
 {
        int ret = NET_ERR_NONE;
-       char *mac = new char[18];
+       void *handle = NULL;
 
-       ret = net_wifi_tdls_connected_peer(&mac);
-       delete[] mac;
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_wifi_tdls_connected_peer_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_tdls_connected_peer(NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_wifi_tdls_disconnect_p)
-{
-       int ret = NET_ERR_NONE;
-       const char *mac = "ff:ff:11:11:11:ff";
-
-       ret = net_wifi_tdls_disconnect(mac);
+       ret = net_stop_tcpdump(handle);
        EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_wifi_tdls_disconnect_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_tdls_disconnect(NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_foreach_ipv6_address_p)
@@ -378,11 +281,15 @@ TEST(LibnetClient, net_get_statistics_p)
 {
        int ret = NET_ERR_NONE;
        unsigned long long size;
+       void *handle = NULL;
 
-       ret = net_get_statistics(NET_DEVICE_WIFI,
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_statistics(handle, NET_DEVICE_WIFI,
                        NET_STATISTICS_TYPE_LAST_RECEIVED_DATA,
                        &size);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_get_statistics_n)
@@ -390,7 +297,7 @@ TEST(LibnetClient, net_get_statistics_n)
        MainLoop M;
        int ret = NET_ERR_NONE;
 
-       ret = net_get_statistics(NET_DEVICE_ETHERNET,
+       ret = net_get_statistics(NULL, NET_DEVICE_ETHERNET,
                        NET_STATISTICS_TYPE_LAST_RECEIVED_DATA,
                        NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
@@ -401,17 +308,21 @@ TEST(LibnetClient, net_get_statistics_n)
 TEST(LibnetClient, net_set_statistics_p)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_set_statistics(NET_DEVICE_WIFI,
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_set_statistics(handle, NET_DEVICE_WIFI,
                        NET_STATISTICS_TYPE_LAST_RECEIVED_DATA);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_set_statistics_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_set_statistics(NET_DEVICE_MAX,
+       ret = net_set_statistics(NULL, NET_DEVICE_MAX,
                        NET_STATISTICS_TYPE_LAST_RECEIVED_DATA);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
@@ -420,16 +331,20 @@ TEST(LibnetClient, net_get_ethernet_cable_state_p)
 {
        int ret = NET_ERR_NONE;
        int state = 0;
+       void *handle = NULL;
 
-       ret = net_get_ethernet_cable_state(&state);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_ethernet_cable_state(handle, &state);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_get_ethernet_cable_state_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_ethernet_cable_state(NULL);
+       ret = net_get_ethernet_cable_state(NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -439,19 +354,23 @@ TEST(LibnetClient, net_add_route_p)
        char ip_addr[40] = "2.7.0.2";
        char if_name[40] = "eth0";
        int address_family = AF_INET;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_add_route(ip_addr, if_name, address_family);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_add_route(handle, ip_addr, if_name, address_family);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_add_route_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_add_route(NULL, NULL, 0);
+       ret = net_add_route(NULL, NULL, NULL, 0);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -462,19 +381,23 @@ TEST(LibnetClient, net_add_route_entry_p)
        char gateway[40] = "2.7.0.1";
        char if_name[40] = "eth0";
        int address_family = AF_INET;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_add_route_entry(ip_addr, if_name, address_family, gateway);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_add_route_entry(handle, ip_addr, if_name, address_family, gateway);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_add_route_entry_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_add_route_entry(NULL, NULL, 0, NULL);
+       ret = net_add_route_entry(NULL, NULL, NULL, 0, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -485,19 +408,23 @@ TEST(LibnetClient, net_remove_route_entry_p)
        char gateway[40] = "2.7.0.1";
        char if_name[40] = "eth0";
        int address_family = AF_INET;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_remove_route_entry(ip_addr, if_name, address_family, gateway);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_remove_route_entry(handle, ip_addr, if_name, address_family, gateway);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_remove_route_entry_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_remove_route_entry(NULL, NULL, 0, NULL);
+       ret = net_remove_route_entry(NULL, NULL, NULL, 0, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -507,62 +434,26 @@ TEST(LibnetClient, net_remove_route_p)
        char ip_addr[40] = "2.7.0.2";
        char if_name[40] = "eth0";
        int address_family = AF_INET;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_remove_route(ip_addr, if_name, address_family);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_remove_route_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_remove_route(NULL, NULL, 0);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_get_technology_properties_p)
-{
-       int ret = NET_ERR_NONE;
-       net_device_t device_type = NET_DEVICE_ETHERNET;
-       net_tech_info_t tech_info;
-
-       ret = net_get_technology_properties(device_type, &tech_info);
-       EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, net_get_technology_properties_n)
-{
-       MainLoop M;
-       int ret = NET_ERR_NONE;
-       net_device_t device_type = NET_DEVICE_ETHERNET;
-
-       ret = net_get_technology_properties(device_type, NULL);
-       EXPECT_NE(ret, NET_ERR_NONE);
-
-       M.run(10);
-}
-
-TEST(LibnetClient, net_wifi_get_passpoint_p)
-{
-       int ret = NET_ERR_NONE;
-       int enabled;
-
-       ret = net_wifi_get_passpoint(&enabled);
+       ret = net_remove_route(handle, ip_addr, if_name, address_family);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
-TEST(LibnetClient, net_wifi_get_passpoint_n)
+TEST(LibnetClient, net_remove_route_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_wifi_get_passpoint(NULL);
+       ret = net_remove_route(NULL, NULL, NULL, 0);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
-
 TEST(LibnetClient, net_add_route_ipv6_p)
 {
        int ret = NET_ERR_NONE;
@@ -570,19 +461,23 @@ TEST(LibnetClient, net_add_route_ipv6_p)
        char if_name[40] = "eth0";
        char gateway[40] = "2001:db8:a0b:12f0::2";
        int address_family = AF_INET6;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_add_route_ipv6(ip_addr, if_name, address_family, gateway);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_add_route_ipv6(handle, ip_addr, if_name, address_family, gateway);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_add_route_ipv6_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_add_route_ipv6(NULL, NULL, 0, NULL);
+       ret = net_add_route_ipv6(NULL, NULL, NULL, 0, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -593,19 +488,23 @@ TEST(LibnetClient, net_remove_route_ipv6_p)
        char if_name[40] = "eth0";
        char gateway[40] = "2001:db8:a0b:12f0::2";
        int address_family = AF_INET6;
+       void *handle = NULL;
 
        g_strstrip(ip_addr);
        g_strstrip(if_name);
 
-       ret = net_remove_route_ipv6(ip_addr, if_name, address_family, gateway);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_remove_route_ipv6(handle, ip_addr, if_name, address_family, gateway);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_remove_route_ipv6_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_remove_route_ipv6(NULL, NULL, 0, NULL);
+       ret = net_remove_route_ipv6(NULL, NULL, NULL, 0, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -613,16 +512,20 @@ TEST(LibnetClient, net_get_metered_state_p)
 {
        int ret = NET_ERR_NONE;
        int ismetered;
+       void *handle = NULL;
 
-       ret = net_get_metered_state(&ismetered);
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
+       ret = net_get_metered_state(handle, &ismetered);
+       EXPECT_EQ(ret, NET_ERR_NONE);
+       net_deregister_client(handle);
 }
 
 TEST(LibnetClient, net_get_metered_state_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_get_metered_state(NULL);
+       ret = net_get_metered_state(NULL, NULL);
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
@@ -630,73 +533,21 @@ TEST(LibnetClient, open_connection_with_profile_n)
 {
        int ret = NET_ERR_NONE;
 
-       ret = net_open_connection_with_profile("gtest");
+       ret = net_open_connection_with_profile(NULL, "gtest");
        EXPECT_NE(ret, NET_ERR_NONE);
 }
 
-TEST(LibnetClient, scan_specific_p)
-{
-       MainLoop M;
-       int ret = NET_ERR_NONE;
-
-       ret = net_wifi_power_on(FALSE);
-
-       M.run(10);
-
-       ret = net_specific_scan_wifi("gtest");
-       ret = (ret == NET_ERR_NONE || ret == NET_ERR_IN_PROGRESS
-                       || ret == NET_ERR_ALREADY_EXISTS);
-       EXPECT_NE(ret, 0);
-
-       M.run(10);
-}
-
-TEST(LibnetClient, scan_p)
-{
-       MainLoop M;
-       int ret = NET_ERR_NONE;
-
-       ret = net_scan_wifi();
-       ret = (ret == NET_ERR_NONE || ret == NET_ERR_IN_PROGRESS);
-       EXPECT_NE(ret, 0);
-
-       M.run(15);
-
-}
-
-TEST(LibnetClient, power_off_p)
-{
-       int ret = NET_ERR_NONE;
-       ret = net_wifi_power_on(FALSE);
-
-       ret = net_wifi_power_off();
-       EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
 TEST(LibnetClient, deregister_p)
 {
        int ret = NET_ERR_NONE;
+       void *handle = NULL;
 
-       ret = net_deregister_client();
+       ret = net_register_client(&handle, (net_event_cb_t)__network_evt_cb, NULL);
        EXPECT_EQ(ret, NET_ERR_NONE);
-}
-
-TEST(LibnetClient, deregister_ext_p)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_deregister_client_ext(NET_DEVICE_DEFAULT);
+       net_deregister_client(handle);
        EXPECT_EQ(ret, NET_ERR_NONE);
 }
 
-TEST(LibnetClient, deregister_ext_n)
-{
-       int ret = NET_ERR_NONE;
-
-       ret = net_deregister_client_ext(NET_DEVICE_MAX);
-       EXPECT_NE(ret, NET_ERR_NONE);
-}
-
 int main(int argc, char **argv)
 {
        InitGoogleTest(&argc, argv);