--- /dev/null
+/*
+* 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.
+*/
+
+#include <gtest/gtest.h>
+
+#include "softap.h"
+
+extern "C" {
+#include "mocks/softap_dummy_client.h"
+#include "mocks/softap_memory.h"
+#include "mocks/softap_permission.h"
+#include "mocks/softap_system_info.h"
+#include "mocks/softap_vconf.h"
+}
+
+class SoftApClientTest: public ::testing::Test {
+ protected:
+ softap_client_h client;
+
+ void SetUp() override
+ {
+ softap_mock_set_memory_result(true);
+ softap_mock_set_sysinfo_result(true);
+ softap_mock_set_permission(true);
+ softap_mock_set_vconf_result(true);
+ softap_mock_create_dummy_client(&client);
+ }
+
+ void TearDown() override
+ {
+ softap_mock_set_vconf_result(false);
+ softap_mock_set_permission(false);
+ softap_mock_set_sysinfo_result(false);
+ softap_mock_set_memory_result(true);
+ softap_mock_destroy_dummy_client(client);
+ }
+};
+
+TEST_F(SoftApClientTest, CloneN)
+{
+ softap_client_h clone = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_clone(NULL, client));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_clone(&clone, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_clone(NULL, NULL));
+
+ softap_mock_set_memory_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OUT_OF_MEMORY, softap_client_clone(&clone, client));
+}
+
+TEST_F(SoftApClientTest, CloneP)
+{
+ softap_client_h clone = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_client_clone(&clone, client));
+
+ softap_client_destroy(clone);
+}
+
+TEST_F(SoftApClientTest, DestroyN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_destroy(NULL));
+}
+
+TEST_F(SoftApClientTest, DestroyP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_client_destroy(client));
+ client = NULL;
+}
+
+TEST_F(SoftApClientTest, GetNameN)
+{
+ char *name = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_name(NULL, &name));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_name(client, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_name(NULL, NULL));
+}
+
+TEST_F(SoftApClientTest, GetNameP)
+{
+ char *name = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_client_get_name(client, &name));
+}
+
+TEST_F(SoftApClientTest, GetIpAddressN)
+{
+ char *ip_address = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_client_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &ip_address));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_client_get_ip_address(client, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_client_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+}
+
+TEST_F(SoftApClientTest, GetIpAddressP)
+{
+ char *ip_address = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_client_get_ip_address(client, SOFTAP_ADDRESS_FAMILY_IPV4, &ip_address));
+}
+
+TEST_F(SoftApClientTest, GetMacAddressN)
+{
+ char *mac_address = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_mac_address(NULL, &mac_address));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_mac_address(client, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_mac_address(NULL, NULL));
+}
+
+TEST_F(SoftApClientTest, GetMacAddressP)
+{
+ char *mac_address = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_client_get_mac_address(client, &mac_address));
+}
+
+TEST_F(SoftApClientTest, GetTimeN)
+{
+ time_t timestamp;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_time(NULL, ×tamp));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_time(client, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_client_get_time(NULL, NULL));
+}
+
+TEST_F(SoftApClientTest, GetTimeP)
+{
+ time_t timestamp;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_client_get_time(client, ×tamp));
+}
--- /dev/null
+/*
+* 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.
+*/
+
+#include <gtest/gtest.h>
+
+#include "softap.h"
+
+extern "C" {
+#include "mocks/softap_gdbus.h"
+#include "mocks/softap_memory.h"
+#include "mocks/softap_system_info.h"
+#include "mocks/softap_permission.h"
+#include "mocks/softap_vconf.h"
+}
+
+class SoftApTest: public ::testing::Test {
+ protected:
+ softap_h handle;
+
+ void SetUp() override
+ {
+ softap_mock_set_gdbus_result(true);
+ softap_mock_set_memory_result(true);
+ softap_mock_set_sysinfo_result(true);
+ softap_mock_set_permission(true);
+ softap_mock_set_vconf_result(true);
+ softap_create(&handle);
+ }
+
+ void TearDown() override
+ {
+ softap_destroy(handle);
+ softap_mock_set_vconf_result(false);
+ softap_mock_set_permission(false);
+ softap_mock_set_sysinfo_result(false);
+ softap_mock_set_memory_result(true);
+ softap_mock_set_gdbus_result(false);
+ }
+};
+
+TEST_F(SoftApTest, CreateHandleN)
+{
+ softap_h test_handle = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_create(NULL));
+
+ softap_mock_set_memory_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OUT_OF_MEMORY, softap_create(&test_handle));
+}
+
+TEST_F(SoftApTest, CreateHandleP)
+{
+ softap_h test_handle = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_create(&test_handle));
+
+ softap_destroy(test_handle);
+}
+
+TEST_F(SoftApTest, DestroyHandleN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_destroy(NULL));
+}
+
+TEST_F(SoftApTest, DestroyHandleP)
+{
+ softap_h test_handle = NULL;
+
+ softap_create(&test_handle);
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_destroy(test_handle));
+}
+
+TEST_F(SoftApTest, IsEnabledN)
+{
+ bool enable = false;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(NULL, &enable));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(NULL, NULL));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_is_enabled(handle, &enable));
+}
+
+TEST_F(SoftApTest, IsEnabledP)
+{
+ bool enable = false;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_is_enabled(handle, &enable));
+}
+
+TEST_F(SoftApTest, GetMacAddressN)
+{
+ char *mac = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(NULL, &mac));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(NULL, NULL));
+
+ softap_mock_set_enabled_state(false);
+ EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED, softap_get_mac_address(handle, &mac));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_mac_address(handle, &mac));
+}
+
+TEST_F(SoftApTest, GetMacAddressP)
+{
+ char *mac = NULL;
+
+ softap_mock_set_enabled_state(true);
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_mac_address(handle, &mac));
+}
+
+TEST_F(SoftApTest, GetNetworkInterfaceNameN)
+{
+ char *interface_name = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_network_interface_name(NULL, &interface_name));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_network_interface_name(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_network_interface_name(NULL, NULL));
+
+ softap_mock_set_enabled_state(false);
+ EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED, softap_get_network_interface_name(handle, &interface_name));
+}
+
+TEST_F(SoftApTest, GetNetworkInterfaceNameP)
+{
+ char *interface_name = NULL;
+
+ softap_mock_set_enabled_state(true);
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_network_interface_name(handle, &interface_name));
+}
+
+TEST_F(SoftApTest, SetIpAddressN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, "192.168.0.1"));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, "..."));
+ EXPECT_EQ(SOFTAP_ERROR_NOT_SUPPORTED,
+ softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV6, "2001::23"));
+}
+
+TEST_F(SoftApTest, SetIpAddressP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, "192.168.0.1"));
+}
+
+TEST_F(SoftApTest, GetIpAddressN)
+{
+ char *ip = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+
+ softap_mock_set_enabled_state(false);
+ EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
+ softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
+}
+
+TEST_F(SoftApTest, GetIpAddressP)
+{
+ char *ip = NULL;
+
+ softap_mock_set_enabled_state(true);
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
+}
+
+TEST_F(SoftApTest, GetGatewayAddressN)
+{
+ char *gateway = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_gateway_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_gateway_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+
+ softap_mock_set_enabled_state(false);
+ EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
+ softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
+}
+
+TEST_F(SoftApTest, GetGatewayAddressP)
+{
+ char *gateway = NULL;
+
+ softap_mock_set_enabled_state(true);
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
+}
+
+TEST_F(SoftApTest, GetSubnetMaskN)
+{
+ char *subnetmask = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_subnet_mask(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_get_subnet_mask(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
+
+ softap_mock_set_enabled_state(false);
+ EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
+ softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
+}
+
+TEST_F(SoftApTest, GetSubnetMaskP)
+{
+ char *subnetmask = NULL;
+
+ softap_mock_set_enabled_state(true);
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
+}
+
+TEST_F(SoftApTest, SetSecurityTypeN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_security_type(NULL, SOFTAP_SECURITY_TYPE_WPA2_PSK));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_set_security_type(handle, (softap_security_type_e)-1));
+}
+
+TEST_F(SoftApTest, SetSecurityTypeP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_set_security_type(handle, SOFTAP_SECURITY_TYPE_NONE));
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_set_security_type(handle, SOFTAP_SECURITY_TYPE_WPA2_PSK));
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_set_security_type(handle, SOFTAP_SECURITY_TYPE_WPS));
+}
+
+TEST_F(SoftApTest, GetSecurityTypeN)
+{
+ softap_security_type_e type;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_security_type(NULL, &type));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_security_type(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_security_type(NULL, NULL));
+}
+
+TEST_F(SoftApTest, GetSecurityTypeP)
+{
+ softap_security_type_e type;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_security_type(handle, &type));
+}
+
+TEST_F(SoftApTest, SetSsidN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_ssid(NULL, "softap-gtest"));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_ssid(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_ssid(NULL, NULL));
+}
+
+TEST_F(SoftApTest, SetSsidP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_ssid(handle, "softap-gtest"));
+}
+
+TEST_F(SoftApTest, GetSsidN)
+{
+ char *ssid = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid(NULL, &ssid));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid(NULL, NULL));
+}
+
+TEST_F(SoftApTest, GetSsidP)
+{
+ char *ssid = NULL;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_ssid(handle, &ssid));
+}
+
+TEST_F(SoftApTest, SetSsidVisibilityN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_ssid_visibility(NULL, true));
+}
+
+TEST_F(SoftApTest, SetSsidVisibilityP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_ssid_visibility(handle, true));
+}
+
+TEST_F(SoftApTest, GetSsidVisibilityN)
+{
+ bool visible;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid_visibility(NULL, &visible));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid_visibility(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_ssid_visibility(NULL, NULL));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_ssid_visibility(handle, &visible));
+}
+
+TEST_F(SoftApTest, GetSsidVisibilityP)
+{
+ bool visible;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_ssid_visibility(handle, &visible));
+}
+
+TEST_F(SoftApTest, SetPassphraseN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_passphrase(NULL, "P@s$w0rd!"));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_passphrase(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_passphrase(NULL, NULL));
+
+ // Too short passphrase
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_passphrase(handle, "123"));
+
+ // Too long passphrase
+ char passphrase[70] = {0, };
+ for (int i = 0; i < 69; i++)
+ passphrase[i] = 'a';
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_passphrase(handle, passphrase));
+}
+
+TEST_F(SoftApTest, SetPassphraseP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_passphrase(handle, "P@s$w0rd!"));
+}
+
+TEST_F(SoftApTest, GetPassphraseN)
+{
+ char *passphrase;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_passphrase(NULL, &passphrase));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_passphrase(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_passphrase(NULL, NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_passphrase(handle, &passphrase));
+}
+
+TEST_F(SoftApTest, GetPassphraseP)
+{
+ char *passphrase;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_passphrase(handle, &passphrase));
+}
+
+TEST_F(SoftApTest, SetVendorElementN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_vendor_element(NULL, "DD050016328000"));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_vendor_element(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_vendor_element(NULL, NULL));
+
+ // Too long element
+ char element[1030] = {0, };
+ for (int i = 0; i < 1029; i++)
+ element[i] = 'a';
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_vendor_element(handle, element));
+}
+
+TEST_F(SoftApTest, SetVendorElementP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_vendor_element(handle, "DD050016328000"));
+}
+
+TEST_F(SoftApTest, GetVendorElementN)
+{
+ char *element;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_vendor_element(NULL, &element));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_vendor_element(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_vendor_element(NULL, NULL));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_vendor_element(handle, &element));
+}
+
+TEST_F(SoftApTest, GetVendorElementP)
+{
+ char *element;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_vendor_element(handle, &element));
+}
+
+TEST_F(SoftApTest, SetChannelN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_channel(NULL, 6));
+}
+
+TEST_F(SoftApTest, SetChannelP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_channel(handle, 6));
+}
+
+TEST_F(SoftApTest, GetChannelN)
+{
+ int channel;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_channel(NULL, &channel));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_channel(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_channel(NULL, NULL));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_channel(handle, &channel));
+}
+
+TEST_F(SoftApTest, GetChannelP)
+{
+ int channel;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_channel(handle, &channel));
+}
+
+TEST_F(SoftApTest, SetModeN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_mode(NULL, SOFTAP_WIRELESS_MODE_B));
+}
+
+TEST_F(SoftApTest, SetModeP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_mode(handle, SOFTAP_WIRELESS_MODE_B));
+}
+
+TEST_F(SoftApTest, GetModeN)
+{
+ softap_wireless_mode_e mode;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mode(NULL, &mode));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mode(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mode(NULL, NULL));
+
+ softap_mock_set_vconf_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_mode(handle, &mode));
+}
+
+TEST_F(SoftApTest, GetModeP)
+{
+ softap_wireless_mode_e mode;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_mode(handle, &mode));
+}
+
+TEST_F(SoftApTest, SetWpsPinN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_wps_pin(NULL, "1234567"));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_wps_pin(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_set_wps_pin(NULL, NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_set_wps_pin(handle, "1234567"));
+}
+
+TEST_F(SoftApTest, SetWpsPinP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_set_wps_pin(handle, "1234567"));
+}
+
+TEST_F(SoftApTest, PushWpsButtonN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_push_wps_button(NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_push_wps_button(handle));
+}
+
+TEST_F(SoftApTest, PushWpsButtonP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_push_wps_button(handle));
+}
+
+TEST_F(SoftApTest, EnableDhcpN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_enable_dhcp(NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_enable_dhcp(handle));
+}
+
+TEST_F(SoftApTest, EnableDhcpP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_enable_dhcp(handle));
+}
+
+TEST_F(SoftApTest, EnableDhcpWithRangeN)
+{
+ char start_ip[16] = "192.168.43.2";
+ char end_ip[16] = "192.168.43.100";
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_enable_dhcp_with_range(NULL, start_ip, end_ip));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_enable_dhcp_with_range(handle, NULL, end_ip));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_enable_dhcp_with_range(handle, start_ip, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_enable_dhcp_with_range(NULL, NULL, NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED,
+ softap_enable_dhcp_with_range(handle, start_ip, end_ip));
+}
+
+TEST_F(SoftApTest, EnableDhcpWithRangeP)
+{
+ char start_ip[16] = "192.168.43.2";
+ char end_ip[16] = "192.168.43.100";
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_enable_dhcp_with_range(handle, start_ip, end_ip));
+}
+
+TEST_F(SoftApTest, DisableDhcpN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_disable_dhcp(NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_disable_dhcp(handle));
+}
+
+TEST_F(SoftApTest, DisableDhcpP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_disable_dhcp(handle));
+}
+
+TEST_F(SoftApTest, IsDhcpEnabledN)
+{
+ bool dhcp_enabled;
+
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_dhcp_enabled(NULL, &dhcp_enabled));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_dhcp_enabled(handle, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_dhcp_enabled(NULL, NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_is_dhcp_enabled(handle, &dhcp_enabled));
+}
+
+TEST_F(SoftApTest, IsDhcpEnabledP)
+{
+ bool dhcp_enabled;
+
+ EXPECT_EQ(SOFTAP_ERROR_NONE, softap_is_dhcp_enabled(handle, &dhcp_enabled));
+}
+
+bool ConnectedClientsCallbackP(softap_client_h client, void *data)
+{
+ return true;
+}
+
+bool ConnectedClientsCallbackN(softap_client_h client, void *data)
+{
+ return false;
+}
+
+TEST_F(SoftApTest, ForeachConnectedClientsN)
+{
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_foreach_connected_clients(NULL, ConnectedClientsCallbackN, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_foreach_connected_clients(handle, NULL, NULL));
+ EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
+ softap_foreach_connected_clients(NULL, NULL, NULL));
+
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED,
+ softap_foreach_connected_clients(handle, ConnectedClientsCallbackN, NULL));
+
+ softap_mock_set_gdbus_result(false);
+ EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED,
+ softap_foreach_connected_clients(handle, ConnectedClientsCallbackN, NULL));
+}
+
+TEST_F(SoftApTest, ForeachConnectedClientsP)
+{
+ EXPECT_EQ(SOFTAP_ERROR_NONE,
+ softap_foreach_connected_clients(handle, ConnectedClientsCallbackP, NULL));
+}
+++ /dev/null
-/*
-* 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.
-*/
-
-#include <gtest/gtest.h>
-
-#include "softap.h"
-
-extern "C" {
-#include "mocks/softap_memory.h"
-#include "mocks/softap_system_info.h"
-#include "mocks/softap_permission.h"
-#include "mocks/softap_vconf.h"
-}
-
-class SoftApTest: public ::testing::Test {
- protected:
- softap_h handle;
-
- void SetUp() override
- {
- softap_mock_set_memory_result(true);
- softap_mock_set_sysinfo_result(true);
- softap_mock_set_permission(true);
- softap_mock_set_vconf_result(true);
- softap_create(&handle);
- }
-
- void TearDown() override
- {
- softap_destroy(handle);
- softap_mock_set_vconf_result(false);
- softap_mock_set_permission(false);
- softap_mock_set_sysinfo_result(false);
- softap_mock_set_memory_result(true);
- }
-};
-
-TEST_F(SoftApTest, CreateHandleN)
-{
- softap_h test_handle = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_create(NULL));
-
- softap_mock_set_memory_result(false);
- EXPECT_EQ(SOFTAP_ERROR_OUT_OF_MEMORY, softap_create(&test_handle));
-}
-
-TEST_F(SoftApTest, CreateHandleP)
-{
- softap_h test_handle = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_NONE, softap_create(&test_handle));
-
- softap_destroy(test_handle);
-}
-
-TEST_F(SoftApTest, DestroyHandleN)
-{
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_destroy(NULL));
-}
-
-TEST_F(SoftApTest, DestroyHandleP)
-{
- softap_h test_handle = NULL;
-
- softap_create(&test_handle);
- EXPECT_EQ(SOFTAP_ERROR_NONE, softap_destroy(test_handle));
-}
-
-TEST_F(SoftApTest, IsEnabledN)
-{
- bool enable = false;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(NULL, &enable));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(handle, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_is_enabled(NULL, NULL));
-
- softap_mock_set_vconf_result(false);
- EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_is_enabled(handle, &enable));
-}
-
-TEST_F(SoftApTest, IsEnabledP)
-{
- bool enable = false;
-
- EXPECT_EQ(SOFTAP_ERROR_NONE, softap_is_enabled(handle, &enable));
-}
-
-TEST_F(SoftApTest, GetMacAddressN)
-{
- char *mac = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(NULL, &mac));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(handle, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_get_mac_address(NULL, NULL));
-
- softap_mock_set_enabled_state(false);
- EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED, softap_get_mac_address(handle, &mac));
-
- softap_mock_set_vconf_result(false);
- EXPECT_EQ(SOFTAP_ERROR_OPERATION_FAILED, softap_get_mac_address(handle, &mac));
-}
-
-TEST_F(SoftApTest, GetMacAddressP)
-{
- char *mac = NULL;
-
- softap_mock_set_enabled_state(true);
- EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_mac_address(handle, &mac));
-}
-
-TEST_F(SoftApTest, SetIpAddressN)
-{
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_set_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, "192.168.0.1"));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_set_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, "..."));
- EXPECT_EQ(SOFTAP_ERROR_NOT_SUPPORTED,
- softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV6, "2001::23"));
-}
-
-TEST_F(SoftApTest, SetIpAddressP)
-{
- EXPECT_EQ(SOFTAP_ERROR_NONE,
- softap_set_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, "192.168.0.1"));
-}
-
-TEST_F(SoftApTest, GetIpAddressN)
-{
- char *ip = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_ip_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
-
- softap_mock_set_enabled_state(false);
- EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
- softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
-}
-
-TEST_F(SoftApTest, GetIpAddressP)
-{
- char *ip = NULL;
-
- softap_mock_set_enabled_state(true);
- EXPECT_EQ(SOFTAP_ERROR_NONE, softap_get_ip_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &ip));
-}
-
-TEST_F(SoftApTest, GetGatewayAddressN)
-{
- char *gateway = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_gateway_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_gateway_address(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
-
- softap_mock_set_enabled_state(false);
- EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
- softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
-}
-
-TEST_F(SoftApTest, GetGatewayAddressP)
-{
- char *gateway = NULL;
-
- softap_mock_set_enabled_state(true);
- EXPECT_EQ(SOFTAP_ERROR_NONE,
- softap_get_gateway_address(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &gateway));
-}
-
-TEST_F(SoftApTest, GetSubnetMaskN)
-{
- char *subnetmask = NULL;
-
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_subnet_mask(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
- EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER,
- softap_get_subnet_mask(NULL, SOFTAP_ADDRESS_FAMILY_IPV4, NULL));
-
- softap_mock_set_enabled_state(false);
- EXPECT_EQ(SOFTAP_ERROR_NOT_PERMITTED,
- softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
-}
-
-TEST_F(SoftApTest, GetSubnetMaskP)
-{
- char *subnetmask = NULL;
-
- softap_mock_set_enabled_state(true);
- EXPECT_EQ(SOFTAP_ERROR_NONE,
- softap_get_subnet_mask(handle, SOFTAP_ADDRESS_FAMILY_IPV4, &subnetmask));
-}
-
-int main(int argc, char **argv)
-{
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
projects / platform / core / api / softap.git / commitdiff