2 * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
23 #include <sys/socket.h>
25 #include <vpn_service.h>
30 #include "network_state.h"
34 using ::testing::InitGoogleTest;
35 using ::testing::Test;
36 using ::testing::TestCase;
39 char *mesh_id = (char *)"gtestnetwork";
41 TEST(NetworkStatistics, GetWifiTotalTxBytes_p)
43 error_e ret = ERROR_NONE;
46 ret = mgr.GetWifiTotalTxBytes();
47 EXPECT_EQ(ERROR_NONE, ret);
50 TEST(NetworkStatistics, GetWifiTotalRxBytes_p)
52 error_e ret = ERROR_NONE;
55 ret = mgr.GetWifiTotalRxBytes();
56 EXPECT_EQ(ERROR_NONE, ret);
59 TEST(NetworkStatistics, GetWifiLastTxBytes_p)
61 error_e ret = ERROR_NONE;
64 ret = mgr.GetWifiLastTxBytes();
65 EXPECT_EQ(ERROR_NONE, ret);
68 TEST(NetworkStatistics, GetWifiLastRxBytes_p)
70 error_e ret = ERROR_NONE;
73 ret = mgr.GetWifiLastRxBytes();
74 EXPECT_EQ(ERROR_NONE, ret);
77 TEST(NetworkStatistics, ResetCellularTotalTxBytes_p)
79 error_e ret = ERROR_NONE;
82 ret = mgr.ResetCellularTotalTxBytes();
83 EXPECT_EQ(ERROR_NONE, ret);
86 TEST(NetworkStatistics, ResetCellularTotalRxBytes_p)
88 error_e ret = ERROR_NONE;
91 ret = mgr.ResetCellularTotalRxBytes();
92 EXPECT_EQ(ERROR_NONE, ret);
95 TEST(NetworkStatistics, ResetCellularLastTxBytes_p)
97 error_e ret = ERROR_NONE;
100 ret = mgr.ResetCellularLastTxBytes();
101 EXPECT_EQ(ERROR_NONE, ret);
104 TEST(NetworkStatistics, ResetCellularLastRxBytes_p)
106 error_e ret = ERROR_NONE;
109 ret = mgr.ResetCellularLastRxBytes();
110 EXPECT_EQ(ERROR_NONE, ret);
113 TEST(NetworkStatistics, ResetWifiTotalTxBytes_p)
115 error_e ret = ERROR_NONE;
118 ret = mgr.ResetWifiTotalTxBytes();
119 EXPECT_EQ(ERROR_NONE, ret);
122 TEST(NetworkStatistics, ResetWifiTotalRxBytes_p)
124 error_e ret = ERROR_NONE;
127 ret = mgr.ResetWifiTotalRxBytes();
128 EXPECT_EQ(ERROR_NONE, ret);
131 TEST(NetworkStatistics, ResetWifiLastTxBytes_p)
133 error_e ret = ERROR_NONE;
136 ret = mgr.ResetWifiLastTxBytes();
137 EXPECT_EQ(ERROR_NONE, ret);
140 TEST(NetworkStatistics, ResetWifiLastRxBytes_p)
142 error_e ret = ERROR_NONE;
145 ret = mgr.ResetWifiLastRxBytes();
146 EXPECT_EQ(ERROR_NONE, ret);
149 TEST(NetworkState, AddRoute_p)
151 error_e ret = ERROR_NONE;
153 const char *ip = "192.168.11.55";
154 const char *mask = "255.255.255.0";
155 const char *interface = "lo";
156 const char *gateway = "192.168.11.1";
159 ret = mgr.AddRoute(ip, mask, interface, gateway,
161 EXPECT_EQ(ERROR_NONE, ret);
162 EXPECT_EQ(true, result);
165 TEST(NetworkState, RemoveRoute_p)
167 error_e ret = ERROR_NONE;
169 const char *ip = "192.168.11.55";
170 const char *mask = "255.255.255.0";
171 const char *interface = "lo";
172 const char *gateway = "192.168.11.1";
175 ret = mgr.RemoveRoute(ip, mask, interface, gateway,
178 EXPECT_EQ(ERROR_NONE, ret);
179 EXPECT_EQ(true, result);
182 TEST(NetworkState, RemoveRoute_n)
184 error_e ret = ERROR_NONE;
188 ret = mgr.RemoveRoute(NULL, NULL, NULL, NULL,
191 EXPECT_NE(ERROR_NONE, ret);
194 TEST(NetworkState, LaunchMdns_p)
196 error_e ret = ERROR_NONE;
198 const char *name = "gtest";
200 ret = mgr.LaunchMdns(name);
201 EXPECT_EQ(ERROR_NONE, ret);
204 TEST(NetworkState, LaunchMdns_n)
206 error_e ret = ERROR_NONE;
208 const char *name = "gtest";
210 ret = mgr.LaunchMdns(name);
211 EXPECT_EQ(ERROR_NONE, ret);
214 TEST(NetworkState, DevicePolicySetWifi_p1)
216 error_e ret = ERROR_NONE;
220 ret = mgr.DevicePolicySetWifi(state);
221 EXPECT_EQ(ERROR_NONE, ret);
222 ret = mgr.DevicePolicyGetWifi(&state);
223 EXPECT_EQ(ERROR_NONE, ret);
227 TEST(NetworkState, DevicePolicySetWifi_p2)
229 error_e ret = ERROR_NONE;
233 ret = mgr.DevicePolicySetWifi(state);
234 EXPECT_EQ(ERROR_NONE, ret);
235 ret = mgr.DevicePolicyGetWifi(&state);
236 EXPECT_EQ(ERROR_NONE, ret);
240 TEST(NetworkState, DevicePolicyGetWifi_p)
242 error_e ret = ERROR_NONE;
246 ret = mgr.DevicePolicyGetWifi(&state);
247 EXPECT_EQ(ERROR_NONE, ret);
250 TEST(NetworkState, DevicePolicyGetWifi_n)
252 error_e ret = ERROR_NONE;
255 ret = mgr.DevicePolicyGetWifi(NULL);
256 EXPECT_EQ(ERROR_NONE, ret);
259 TEST(NetworkState, DevicePolicySetWifiProfile_p1)
261 error_e ret = ERROR_NONE;
265 ret = mgr.DevicePolicySetWifiProfile(state);
266 EXPECT_EQ(ERROR_NONE, ret);
267 ret = mgr.DevicePolicyGetWifiProfile(&state);
268 EXPECT_EQ(ERROR_NONE, ret);
272 TEST(NetworkState, DevicePolicySetWifiProfile_p2)
274 error_e ret = ERROR_NONE;
278 ret = mgr.DevicePolicySetWifiProfile(state);
279 EXPECT_EQ(ERROR_NONE, ret);
280 ret = mgr.DevicePolicyGetWifiProfile(&state);
281 EXPECT_EQ(ERROR_NONE, ret);
285 TEST(NetworkState, DevicePolicySetWifiProfile_n)
287 error_e ret = ERROR_NONE;
291 ret = mgr.DevicePolicySetWifiProfile(state);
292 EXPECT_EQ(ERROR_NONE, ret);
295 TEST(NetworkState, DevicePolicyGetWifiProfile_p)
297 error_e ret = ERROR_NONE;
301 ret = mgr.DevicePolicyGetWifiProfile(&state);
302 EXPECT_EQ(ERROR_NONE, ret);
305 TEST(NetworkState, GetMeteredInfo_p)
307 error_e ret = ERROR_NONE;
311 ret = mgr.GetMeteredInfo(&state);
312 EXPECT_EQ(ERROR_NONE, ret);
315 TEST(NetworkState, GetMeteredInfo_n)
317 error_e ret = ERROR_NONE;
321 ret = mgr.GetMeteredInfo(&state);
322 EXPECT_EQ(ERROR_NONE, ret);
325 TEST(NetworkState, GetTCPDumpState_p)
327 error_e ret = ERROR_NONE;
331 ret = mgr.GetTCPDumpState(&state);
332 EXPECT_EQ(ERROR_NONE, ret);
335 TEST(NetworkState, GetTCPDumpState_n)
337 error_e ret = ERROR_NONE;
340 ret = mgr.GetTCPDumpState(NULL);
341 EXPECT_EQ(ERROR_NONE, ret);
344 TEST(NetworkState, StartTCPDump_p)
346 error_e ret = ERROR_NONE;
350 ret = mgr.StartTCPDump();
351 EXPECT_EQ(ERROR_NONE, ret);
354 ret = mgr.GetTCPDumpState(&state);
355 EXPECT_EQ(ERROR_NONE, ret);
356 EXPECT_EQ(state, true);
359 TEST(NetworkState, StartTCPDump_n)
361 error_e ret = ERROR_NONE;
366 ret = mgr.StartTCPDump();
367 EXPECT_EQ(ERROR_NONE, ret);
370 ret = mgr.GetTCPDumpState(&state);
371 EXPECT_EQ(ERROR_NONE, ret);
372 EXPECT_NE(state, false);
374 wifi_mgr.LoadDriver(false);
377 TEST(NetworkState, StopTCPDump_p)
379 error_e ret = ERROR_NONE;
383 ret = mgr.StopTCPDump();
384 EXPECT_EQ(ERROR_NONE, ret);
387 ret = mgr.GetTCPDumpState(&state);
388 EXPECT_EQ(ERROR_NONE, ret);
389 EXPECT_EQ(state, false);
392 TEST(NetworkState, StopTCPDump_n)
394 error_e ret = ERROR_NONE;
398 ret = mgr.StopTCPDump();
399 EXPECT_EQ(ERROR_NONE, ret);
402 ret = mgr.GetTCPDumpState(&state);
403 EXPECT_EQ(ERROR_NONE, ret);
404 EXPECT_NE(state, true);
406 TEST(NetworkState, PreferredIpv6Address_n)
408 error_e ret = ERROR_NONE;
410 const char *profile = "gtest";
413 ret = mgr.PreferredIpv6Address(profile, address);
414 EXPECT_NE(ERROR_NONE, ret);
417 TEST(VpnTest, vpn_init_p)
419 error_e ret = ERROR_NONE;
421 const char *iface_name = "tun0";
422 int iface_name_len = 4;
427 ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
428 EXPECT_EQ(ERROR_NONE, ret);
429 EXPECT_EQ(result, VPNSVC_ERROR_NONE);
432 TEST(VpnTest, vpn_init_n)
434 error_e ret = ERROR_NONE;
436 const char *iface_name = "gtest";
437 int iface_name_len = 5;
442 ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
443 EXPECT_EQ(ERROR_NONE, ret);
444 EXPECT_EQ(result, false);
447 TEST(VpnTest, vpn_deinit_p)
449 error_e ret = ERROR_NONE;
451 const char *dev_name = "tun0";
454 ret = mgr.vpn_deinit(dev_name, &result);
455 EXPECT_EQ(ERROR_NONE, ret);
458 TEST(VpnTest, vpn_deinit_n)
460 error_e ret = ERROR_NONE;
462 const char *dev_name = "gtest";
465 ret = mgr.vpn_deinit(dev_name, &result);
466 EXPECT_EQ(ERROR_NONE, ret);
467 EXPECT_EQ(result, false);
470 TEST(VpnTest, vpn_protect_p)
472 error_e ret = ERROR_NONE;
474 const char *iface_name = "tun0";
475 int iface_name_len = 5;
480 ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
481 EXPECT_EQ(ERROR_NONE, ret);
482 EXPECT_EQ(result, VPNSVC_ERROR_NONE);
484 const char *dev_name = "tun0";
486 ret = mgr.vpn_protect(dev_name, &result);
487 EXPECT_EQ(ERROR_NONE, ret);
490 TEST(VpnTest, vpn_protect_n)
492 error_e ret = ERROR_NONE;
494 const char *dev_name = "gtest";
497 ret = mgr.vpn_deinit(dev_name, &result);
498 EXPECT_EQ(ERROR_NONE, ret);
499 EXPECT_NE(VPNSVC_ERROR_NONE, result);
502 TEST(VpnTest, vpn_up_p)
504 error_e ret = ERROR_NONE;
506 const char *iface_name = "wlan0";
509 ret = mgr.vpn_up(iface_name, &result);
510 EXPECT_EQ(ERROR_NONE, ret);
513 TEST(VpnTest, vpn_up_n)
515 error_e ret = ERROR_NONE;
517 const char *iface_name = "wlan0";
520 ret = mgr.vpn_up(iface_name, &result);
521 EXPECT_EQ(ERROR_NONE, ret);
522 EXPECT_NE(VPNSVC_ERROR_NONE, result);
525 TEST(VpnTest, vpn_down_p)
527 error_e ret = ERROR_NONE;
529 const char *iface_name = "wlan0";
532 ret = mgr.vpn_up(iface_name, &result);
533 EXPECT_EQ(ERROR_NONE, ret);
536 TEST(VpnTest, vpn_down_n)
538 error_e ret = ERROR_NONE;
540 const char *iface_name = "wlan0";
543 ret = mgr.vpn_up(iface_name, &result);
544 EXPECT_EQ(ERROR_NONE, ret);
545 EXPECT_NE(VPNSVC_ERROR_NONE, result);
548 TEST(VpnTest, vpn_block_networks_p)
550 error_e ret = ERROR_NONE;
553 GVariantBuilder nets_builder;
554 GVariant *nets_param_vpn;
555 GVariant *nets_param_orig;
557 g_variant_builder_init(&nets_builder, G_VARIANT_TYPE("a{si}"));
558 g_variant_builder_add(&nets_builder, "{si}", "1.1.1.1", 24);
559 nets_param_vpn = g_variant_builder_end(&nets_builder);
561 g_variant_builder_init(&nets_builder, G_VARIANT_TYPE("a{si}"));
562 g_variant_builder_add(&nets_builder, "{si}", "2.2.2.2", 24);
563 nets_param_orig = g_variant_builder_end(&nets_builder);
565 ret = mgr.vpn_block_networks(nets_param_vpn, 1, nets_param_orig, 1, &result);
566 EXPECT_EQ(ERROR_NONE, ret);
569 TEST(VpnTest, vpn_unblock_networks_p)
571 error_e ret = ERROR_NONE;
575 ret = mgr.vpn_unblock_networks(&result);
576 EXPECT_EQ(ERROR_NONE, ret);
579 TEST(VpnTest, vpn_update_settings_p)
581 error_e ret = ERROR_NONE;
584 const char *local_ip = "192.168.0.2";
585 const char *remote_ip = "192.168.0.3";
589 ret = mgr.vpn_update_settings(iface_index, local_ip,
590 remote_ip, mtu, &result);
591 EXPECT_EQ(ERROR_NONE, ret);
594 TEST(VpnTest, vpn_update_settings_n)
596 error_e ret = ERROR_NONE;
600 ret = mgr.vpn_update_settings(0, NULL, NULL, 0, &result);
601 EXPECT_EQ(ERROR_NONE, ret);
602 EXPECT_NE(VPNSVC_ERROR_NONE, result);
605 TEST(VpnTest, vpn_add_route_p)
607 error_e ret = ERROR_NONE;
609 const char *iface_name = "wlan0";
610 const char *route = "gtest";
614 ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
615 EXPECT_EQ(ERROR_NONE, ret);
618 TEST(VpnTest, vpn_add_route_n)
620 error_e ret = ERROR_NONE;
622 const char *iface_name = "wlan0";
623 const char *route = "gtest";
627 ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
628 EXPECT_EQ(ERROR_NONE, ret);
629 EXPECT_NE(VPNSVC_ERROR_NONE, result);
632 TEST(VpnTest, vpn_remove_route_p)
634 error_e ret = ERROR_NONE;
636 const char *iface_name = "wlan0";
637 const char *route = "gtest";
641 ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
642 EXPECT_EQ(ERROR_NONE, ret);
645 TEST(VpnTest, vpn_remove_route_n)
647 error_e ret = ERROR_NONE;
649 const char *iface_name = "wlan0";
650 const char *route = "gtest";
654 ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
655 EXPECT_EQ(ERROR_NONE, ret);
656 EXPECT_NE(VPNSVC_ERROR_NONE, result);
659 TEST(VpnTest, vpn_add_dns_server_p)
661 error_e ret = ERROR_NONE;
663 const char *iface_name = "wlan0";
664 const char *dns_server = "1.1.1.1";
667 ret = mgr.vpn_add_dns_server(iface_name, dns_server, &result);
668 EXPECT_EQ(ERROR_NONE, ret);
671 TEST(VpnTest, vpn_add_dns_server_n)
673 error_e ret = ERROR_NONE;
675 const char *iface_name = "wlan0";
676 const char *dns_server = "1.1.1.1";
679 ret = mgr.vpn_add_dns_server(iface_name, dns_server, &result);
680 EXPECT_EQ(ERROR_NONE, ret);
681 EXPECT_NE(VPNSVC_ERROR_NONE, result);
684 TEST(WifiTest, GetWifiState_p)
686 error_e ret = ERROR_NONE;
690 ret = mgr.GetWifiState(state);
691 EXPECT_EQ(ERROR_NONE, ret);
695 TEST(WifiTest, IsIpConflictDetectEnabled_p)
697 error_e ret = ERROR_NONE;
701 ret = mgr.IsIpConflictDetectEnabled(&state);
702 EXPECT_EQ(ERROR_NONE, ret);
706 TEST(WifiTest, SetBgscan_p)
708 error_e ret = ERROR_NONE;
712 ret = mgr.SetBgscan(scan_mode);
713 EXPECT_EQ(ERROR_NONE, ret);
717 TEST(WifiTest, GetAutoscan_p)
719 error_e ret = ERROR_NONE;
723 ret = mgr.GetAutoscan(&state);
724 EXPECT_EQ(ERROR_NONE, ret);
728 TEST(WifiTest, GetIpConflictState_p)
730 error_e ret = ERROR_NONE;
734 ret = mgr.GetIpConflictState(&state);
735 EXPECT_EQ(ERROR_NONE, ret);
739 TEST(WifiTest, GetIpConflictPeriod_p)
741 error_e ret = ERROR_NONE;
745 ret = mgr.GetIpConflictPeriod(&period);
746 EXPECT_EQ(ERROR_NONE, ret);
750 TEST(WifiTest, GetAutoscanmode_p)
752 error_e ret = ERROR_NONE;
756 ret = mgr.GetAutoscanmode(&autoscanmode);
757 EXPECT_EQ(ERROR_NONE, ret);
761 TEST(WifiTest, NetlinkScan_p)
763 error_e ret = ERROR_NONE;
765 const char *ssid = "gtest";
767 ret = mgr.NetlinkScan(ssid);
768 EXPECT_EQ(ERROR_NONE, ret);
772 TEST(WifiTest, RequestWpsConnect_p)
774 error_e ret = ERROR_NONE;
776 const char *param = "PBC";
778 ret = mgr.RequestWpsConnect(param);
779 EXPECT_EQ(ERROR_NONE, ret);
783 TEST(WifiTest, GetPasspoint_p)
785 error_e ret = ERROR_NONE;
789 ret = mgr.GetPasspoint(&enable);
790 EXPECT_EQ(ERROR_NONE, ret);
794 TEST(WifiTest, SetPasspoint_p)
796 error_e ret = ERROR_NONE;
800 ret = mgr.SetPasspoint(enable);
801 EXPECT_EQ(ERROR_NONE, ret);
805 TEST(WifiTest, GetConfigIds_p)
807 error_e ret = ERROR_NONE;
810 ret = mgr.GetConfigIds();
811 EXPECT_EQ(ERROR_NONE, ret);
815 TEST(WifiTest, SaveConfiguration_p)
817 error_e ret = ERROR_NONE;
819 const char *config_id = "gtest";
820 const char *name = "gtest";
821 const char *ssid = "gtest";
823 ret = mgr.SaveConfiguration(config_id, name, ssid, NULL);
824 EXPECT_EQ(ERROR_NONE, ret);
827 TEST(WifiTest, SaveEapConfiguration_p)
829 error_e ret = ERROR_NONE;
831 const char *config_id = "gtest";
832 const char *name = "gtest";
833 const char *ssid = "gtest";
835 ret = mgr.SaveEapConfiguration(config_id, name, ssid);
836 EXPECT_EQ(ERROR_NONE, ret);
840 TEST(WifiTest, SetIpConflictPeriod_p)
842 error_e ret = ERROR_NONE;
844 unsigned int period = 25000;
846 ret = mgr.SetIpConflictPeriod(period);
847 EXPECT_EQ(ERROR_NONE, ret);
851 TEST(WifiTest, SetIpConflictPeriod_n)
853 error_e ret = ERROR_NONE;
855 unsigned int period = 10;
857 ret = mgr.SetIpConflictPeriod(period);
858 EXPECT_NE(ERROR_NONE, ret);
862 TEST(WifiTest, LoadConfiguration_p)
864 error_e ret = ERROR_NONE;
866 const char *config_id = "gtest_managed_none";
867 const char *name = "gtest";
868 const char *ssid = "gtest";
870 ret = mgr.SaveConfiguration(config_id, name, ssid, NULL);
871 EXPECT_EQ(ERROR_NONE, ret);
875 ret = mgr.LoadConfiguration(config_id);
876 EXPECT_EQ(ERROR_NONE, ret);
880 TEST(WifiTest, LoadConfiguration_n)
882 error_e ret = ERROR_NONE;
884 const char *config_id = "\0";
886 ret = mgr.LoadConfiguration(config_id);
887 EXPECT_NE(ERROR_NONE, ret);
890 TEST(WifiTest, LoadEapConfiguration_p)
892 error_e ret = ERROR_NONE;
894 const char *config_id = "gtest_managed_ieee8021x";
895 const char *name = "gtest";
896 const char *ssid = "gtest";
898 ret = mgr.SaveEapConfiguration(config_id, name, ssid);
899 EXPECT_EQ(ERROR_NONE, ret);
903 ret = mgr.LoadEapConfiguration(config_id);
904 EXPECT_EQ(ERROR_NONE, ret);
908 TEST(WifiTest, LoadEapConfiguration_n)
910 error_e ret = ERROR_NONE;
912 const char *config_id = "\0";
914 ret = mgr.LoadEapConfiguration(config_id);
915 EXPECT_NE(ERROR_NONE, ret);
919 TEST(WifiTest, RemoveConfiguration_p)
921 error_e ret = ERROR_NONE;
923 const char *config_id = "gtest";
925 ret = mgr.RemoveConfiguration(config_id);
926 EXPECT_EQ(ERROR_NONE, ret);
930 TEST(WifiTest, RemoveConfiguration_n)
932 error_e ret = ERROR_NONE;
934 const char *config_id = "\0";
936 ret = mgr.RemoveConfiguration(config_id);
937 EXPECT_NE(ERROR_NONE, ret);
941 TEST(WifiTest, SetConfigField_p)
943 error_e ret = ERROR_NONE;
945 const char *config_id = "gtest";
946 const char *key = "Identity";
947 const char *value = "gtest";
949 ret = mgr.SetConfigField(config_id, key, value);
950 EXPECT_EQ(ERROR_NONE, ret);
954 TEST(WifiTest, SetConfigField_n)
956 error_e ret = ERROR_NONE;
958 const char *config_id = "\0";
959 const char *key = "\0";
960 const char *value = "\0";
962 ret = mgr.SetConfigField(config_id, key, value);
963 EXPECT_NE(ERROR_NONE, ret);
967 TEST(WifiTest, GetConfigPassphrase_p)
969 error_e ret = ERROR_NONE;
972 const char *config_id = "gtest";
973 const char *name = "gtest";
974 const char *ssid = "gtest";
975 const char *passphrase = "gtest";
977 ret = mgr.SaveConfiguration(config_id, name, ssid, passphrase);
978 EXPECT_EQ(ERROR_NONE, ret);
982 ret = mgr.GetConfigPassphrase(config_id, password);
983 EXPECT_EQ(ERROR_NONE, ret);
986 TEST(WifiTest, GetConfigPassphrase_n)
988 error_e ret = ERROR_NONE;
990 const char *config_id = "\0";
993 ret = mgr.GetConfigPassphrase(config_id, password);
994 EXPECT_NE(ERROR_NONE, ret);
998 TEST(WifiTest, CreateEapConfig_p)
1000 error_e ret = ERROR_NONE;
1002 const char *profile_name =
1003 "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x";
1005 ret = mgr.CreateEapConfig(profile_name);
1006 EXPECT_EQ(ERROR_NONE, ret);
1010 TEST(WifiTest, CreateEapConfig_n)
1012 error_e ret = ERROR_NONE;
1014 const char *profile_name = "/gtest";
1016 ret = mgr.CreateEapConfig(profile_name);
1017 EXPECT_NE(ERROR_NONE, ret);
1020 TEST(WifiTest, DeleteEapConfig_p)
1022 error_e ret = ERROR_NONE;
1024 const char *profile_name =
1025 "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x";
1027 ret = mgr.CreateEapConfig(profile_name);
1028 EXPECT_EQ(ERROR_NONE, ret);
1030 ret = mgr.DeleteEapConfig(profile_name);
1031 EXPECT_EQ(ERROR_NONE, ret);
1034 TEST(WifiTest, IpConflictSetEnable_p)
1036 error_e ret = ERROR_NONE;
1040 ret = mgr.IsIpConflictDetectEnabled(&state);
1041 EXPECT_EQ(ERROR_NONE, ret);
1043 ret = mgr.IpConflictSetEnable(!state);
1044 EXPECT_EQ(ERROR_NONE, ret);
1047 TEST(WifiTest, ReqSimAuth_p)
1049 error_e ret = ERROR_NONE;
1051 const unsigned char *rand_data = (unsigned char *)"0123456789012345";
1052 unsigned int length = 16;
1055 ret = mgr.ReqSimAuth(rand_data, length, &result);
1056 EXPECT_EQ(ERROR_NONE, ret);
1060 TEST(WifiTest, ReqSimAuth_n)
1062 error_e ret = ERROR_NONE;
1064 unsigned char rand[5] = {0, };
1065 const unsigned char *rand_data = (unsigned char *)rand;
1066 unsigned int length = 5;
1069 ret = mgr.ReqSimAuth(rand_data, length, &result);
1070 EXPECT_NE(ERROR_NONE, ret);
1074 TEST(WifiTest, ReqAkaAuth_p)
1076 error_e ret = ERROR_NONE;
1078 unsigned char rand[] = {65, 61, 62, 63, 64, 65, 66, 67,
1079 68, 69, 70, 71, 72, 73, 74, 75};
1080 unsigned char auth[] = {65, 61, 62, 63, 64, 65, 66, 67,
1081 68, 69, 70, 71, 72, 73, 74, 75};
1082 const unsigned char *rand_data = (unsigned char *)rand;
1083 const unsigned char *auth_data = (unsigned char *)auth;
1087 ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1088 EXPECT_EQ(ERROR_NONE, ret);
1092 TEST(WifiTest, ReqAkaAuth_n)
1094 error_e ret = ERROR_NONE;
1096 unsigned char rand[5] = {0, };
1097 unsigned char auth[5] = {0, };
1098 const unsigned char *rand_data = (unsigned char *)rand;
1099 const unsigned char *auth_data = (unsigned char *)auth;
1103 ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1104 EXPECT_NE(ERROR_NONE, ret);
1108 TEST(WifiTest, CheckBlackList_p)
1110 error_e ret = ERROR_NONE;
1112 const char *name = "gtest";
1113 const char *sec_type = "gtest";
1114 const char *eap = "gtest";
1117 ret = mgr.CheckBlackList(name, sec_type, eap, &allowed);
1118 EXPECT_EQ(ERROR_NONE, ret);
1122 TEST(WifiTest, TdlsDisconnect_p)
1124 error_e ret = ERROR_NONE;
1127 const char *peer_mac_address = "00:00:00:00:00:00";
1129 ret = mgr.TdlsDisconnect(peer_mac_address, &result);
1130 EXPECT_EQ(ERROR_NONE, ret);
1134 TEST(WifiTest, TdlsConnectedPeer_p)
1136 error_e ret = ERROR_NONE;
1138 char peer_mac_address[256];
1140 ret = mgr.TdlsConnectedPeer(peer_mac_address);
1141 EXPECT_EQ(ERROR_NONE, ret);
1145 TEST(WifiTest, TdlsDiscover_n)
1147 error_e ret = ERROR_NONE;
1150 const char *peer_mac_address = "\0";
1152 ret = mgr.TdlsDiscover(peer_mac_address, &result);
1153 EXPECT_NE(ERROR_NONE, ret);
1157 TEST(WifiTest, TdlsChannelSwitch_p)
1159 error_e ret = ERROR_NONE;
1162 const char *peer_mac_address = "00:00:00:00:00:00";
1165 ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1166 EXPECT_EQ(ERROR_NONE, ret);
1167 EXPECT_NE(result, 0);
1170 TEST(WifiTest, TdlsChannelSwitch_n)
1172 error_e ret = ERROR_NONE;
1175 const char *peer_mac_address = "\0";
1178 ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1179 EXPECT_EQ(ERROR_NONE, ret);
1180 EXPECT_NE(result, 0);
1183 TEST(WifiTest, TdlsCancelChannelSwitch_p)
1185 error_e ret = ERROR_NONE;
1188 const char *peer_mac_address = "00:00:00:00:00:00";
1190 ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1191 EXPECT_EQ(ERROR_NONE, ret);
1194 TEST(WifiTest, TdlsCancelChannelSwitch_n)
1196 error_e ret = ERROR_NONE;
1199 const char *peer_mac_address = "\0";
1201 ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1202 EXPECT_EQ(ERROR_NONE, ret);
1203 EXPECT_NE(result, 0);
1206 TEST(WifiTest, AddVsie_p)
1208 error_e ret = ERROR_NONE;
1211 const char *vsie = "dd050016328000";
1213 ret = mgr.AddVsie(frame_id, vsie);
1214 EXPECT_EQ(ERROR_NONE, ret);
1218 TEST(WifiTest, AddVsie_n)
1220 error_e ret = ERROR_NONE;
1223 const char *vsie = "\0";
1225 ret = mgr.AddVsie(frame_id, vsie);
1226 EXPECT_NE(ERROR_NONE, ret);
1229 TEST(WifiTest, GetVsie_p)
1231 error_e ret = ERROR_NONE;
1236 ret = mgr.GetVsie(frame_id, vsie);
1237 EXPECT_EQ(ERROR_NONE, ret);
1241 TEST(WifiTest, GetVsie_n)
1243 error_e ret = ERROR_NONE;
1248 ret = mgr.GetVsie(frame_id, vsie);
1249 EXPECT_NE(ERROR_NONE, ret);
1253 TEST(WifiTest, RemoveVsie_p)
1255 error_e ret = ERROR_NONE;
1258 const char *vsie = "dd050016328000";
1260 ret = mgr.RemoveVsie(frame_id, vsie);
1261 EXPECT_EQ(ERROR_NONE, ret);
1265 TEST(WifiTest, RemoveVsie_n)
1267 error_e ret = ERROR_NONE;
1270 const char *vsie = "\0";
1272 ret = mgr.RemoveVsie(frame_id, vsie);
1273 EXPECT_NE(ERROR_NONE, ret);
1277 TEST(WifiTest, EncryptPassphrase_p)
1279 error_e ret = ERROR_NONE;
1281 const char *passphrase = "gtest";
1282 char *enc_data = NULL;
1284 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1286 EXPECT_EQ(ERROR_NONE, ret);
1289 TEST(WifiTest, EncryptPassphrase_n)
1291 error_e ret = ERROR_NONE;
1293 const char *passphrase = "\0";
1294 char *enc_data = NULL;
1296 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1298 EXPECT_EQ(ERROR_NONE, ret);
1301 TEST(WifiTest, DecryptPassphrase_p)
1303 error_e ret = ERROR_NONE;
1306 const char *passphrase = "0123456789";
1307 char *enc_data = NULL;
1308 char *passphrase1 = NULL;
1310 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1311 EXPECT_EQ(ERROR_NONE, ret);
1312 ret = mgr.DecryptPassphrase(enc_data, &passphrase1);
1313 std::cerr << "decrypted password = " << passphrase1;
1314 std::cerr << " " << "expected = " << passphrase << endl;
1315 EXPECT_EQ(!strcmp(passphrase1, passphrase), true);
1319 EXPECT_EQ(ERROR_NONE, ret);
1322 TEST(WifiTest, DecryptPassphrase_n)
1324 error_e ret = ERROR_NONE;
1326 char *passphrase = NULL;
1327 const char enc_data[] = "\0";
1329 ret = mgr.DecryptPassphrase(enc_data, &passphrase);
1331 EXPECT_NE(ERROR_NONE, ret);
1334 TEST(WifiTest, Stop_n)
1336 error_e ret = ERROR_NONE;
1339 ret = mgr.RemoveDriver();
1340 EXPECT_EQ(ERROR_NONE, ret);
1344 ret = mgr.Stop("gtest");
1345 EXPECT_NE(ERROR_NONE, ret);
1348 TEST(WifiTest, Start_p)
1350 error_e ret = ERROR_NONE;
1353 ret = mgr.Start("softap");
1354 EXPECT_EQ(ERROR_NONE, ret);
1357 TEST(WifiTest, Stop_p)
1359 error_e ret = ERROR_NONE;
1363 ret = mgr.Stop("softap");
1364 EXPECT_EQ(ERROR_NONE, ret);
1367 TEST(WifiTest, Start_n)
1369 error_e ret = ERROR_NONE;
1372 ret = mgr.Start("gtest");
1373 EXPECT_NE(ERROR_NONE, ret);
1376 int main(int argc, char **argv)
1381 testing::InitGoogleTest(&argc, argv);
1383 std::cout << "Exception occurred." << std::endl;
1387 ret = RUN_ALL_TESTS();
1388 } catch (const ::testing::internal::GoogleTestFailureException& e) {
1390 std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl;