From: Cheoleun Moon Date: Tue, 23 Jun 2020 06:35:55 +0000 (+0900) Subject: Add unittests for peer and data-path X-Git-Tag: submit/tizen/20200629.050408~6 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F88%2F236888%2F4;p=platform%2Fcore%2Fapi%2Fwifi-aware.git 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 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 +#include + +#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 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 + +#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 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 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 + +#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 --- 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 --- 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 #include #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 --- 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 --- 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 #include #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 --- 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 --- 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 #include #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 --- 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 --- 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 +#include + #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 --- 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 --- a/tests/unittest/wifi-aware-unittest.cpp +++ b/tests/unittest/wifi-aware-unittest.cpp @@ -14,7 +14,6 @@ * limitations under the License. */ -#include #include #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"); }