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 *)"01234567890123456";
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 const unsigned char *rand_data = (unsigned char *)"\0";
1065 unsigned int length = 5;
1068 ret = mgr.ReqSimAuth(rand_data, length, &result);
1069 EXPECT_NE(ERROR_NONE, ret);
1073 TEST(WifiTest, ReqAkaAuth_p)
1075 error_e ret = ERROR_NONE;
1077 unsigned char rand[] = {65, 61, 62, 63, 64, 65, 66, 67,
1078 68, 69, 70, 71, 72, 73, 74, 75};
1079 unsigned char autn[] = {65, 61, 62, 63, 64, 65, 66, 67,
1080 68, 69, 70, 71, 72, 73, 74, 75};
1081 const unsigned char *rand_data = (unsigned char *)rand;
1082 const unsigned char *auth_data = (unsigned char *)autn;
1086 ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1087 EXPECT_EQ(ERROR_NONE, ret);
1091 TEST(WifiTest, ReqAkaAuth_n)
1093 error_e ret = ERROR_NONE;
1095 const unsigned char *rand_data = (unsigned char *)"\0";
1096 const unsigned char *auth_data = (unsigned char *)"\0";
1100 ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1101 EXPECT_NE(ERROR_NONE, ret);
1105 TEST(WifiTest, CheckBlackList_p)
1107 error_e ret = ERROR_NONE;
1109 const char *name = "gtest";
1110 const char *sec_type = "gtest";
1111 const char *eap = "gtest";
1114 ret = mgr.CheckBlackList(name, sec_type, eap, &allowed);
1115 EXPECT_EQ(ERROR_NONE, ret);
1119 TEST(WifiTest, TdlsDisconnect_p)
1121 error_e ret = ERROR_NONE;
1124 const char *peer_mac_address = "00:00:00:00:00:00";
1126 ret = mgr.TdlsDisconnect(peer_mac_address, &result);
1127 EXPECT_EQ(ERROR_NONE, ret);
1131 TEST(WifiTest, TdlsConnectedPeer_p)
1133 error_e ret = ERROR_NONE;
1135 char peer_mac_address[256];
1137 ret = mgr.TdlsConnectedPeer(peer_mac_address);
1138 EXPECT_EQ(ERROR_NONE, ret);
1142 TEST(WifiTest, TdlsDiscover_n)
1144 error_e ret = ERROR_NONE;
1147 const char *peer_mac_address = "\0";
1149 ret = mgr.TdlsDiscover(peer_mac_address, &result);
1150 EXPECT_NE(ERROR_NONE, ret);
1154 TEST(WifiTest, TdlsChannelSwitch_p)
1156 error_e ret = ERROR_NONE;
1159 const char *peer_mac_address = "00:00:00:00:00:00";
1162 ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1163 EXPECT_EQ(ERROR_NONE, ret);
1164 EXPECT_NE(result, 0);
1167 TEST(WifiTest, TdlsChannelSwitch_n)
1169 error_e ret = ERROR_NONE;
1172 const char *peer_mac_address = "\0";
1175 ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1176 EXPECT_EQ(ERROR_NONE, ret);
1177 EXPECT_NE(result, 0);
1180 TEST(WifiTest, TdlsCancelChannelSwitch_p)
1182 error_e ret = ERROR_NONE;
1185 const char *peer_mac_address = "00:00:00:00:00:00";
1187 ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1188 EXPECT_EQ(ERROR_NONE, ret);
1191 TEST(WifiTest, TdlsCancelChannelSwitch_n)
1193 error_e ret = ERROR_NONE;
1196 const char *peer_mac_address = "\0";
1198 ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1199 EXPECT_EQ(ERROR_NONE, ret);
1200 EXPECT_NE(result, 0);
1203 TEST(WifiTest, AddVsie_p)
1205 error_e ret = ERROR_NONE;
1208 const char *vsie = "dd050016328000";
1210 ret = mgr.AddVsie(frame_id, vsie);
1211 EXPECT_EQ(ERROR_NONE, ret);
1215 TEST(WifiTest, AddVsie_n)
1217 error_e ret = ERROR_NONE;
1220 const char *vsie = "\0";
1222 ret = mgr.AddVsie(frame_id, vsie);
1223 EXPECT_NE(ERROR_NONE, ret);
1226 TEST(WifiTest, GetVsie_p)
1228 error_e ret = ERROR_NONE;
1233 ret = mgr.GetVsie(frame_id, vsie);
1234 EXPECT_EQ(ERROR_NONE, ret);
1238 TEST(WifiTest, GetVsie_n)
1240 error_e ret = ERROR_NONE;
1245 ret = mgr.GetVsie(frame_id, vsie);
1246 EXPECT_NE(ERROR_NONE, ret);
1250 TEST(WifiTest, RemoveVsie_p)
1252 error_e ret = ERROR_NONE;
1255 const char *vsie = "dd050016328000";
1257 ret = mgr.RemoveVsie(frame_id, vsie);
1258 EXPECT_EQ(ERROR_NONE, ret);
1262 TEST(WifiTest, RemoveVsie_n)
1264 error_e ret = ERROR_NONE;
1267 const char *vsie = "\0";
1269 ret = mgr.RemoveVsie(frame_id, vsie);
1270 EXPECT_NE(ERROR_NONE, ret);
1274 TEST(WifiTest, EncryptPassphrase_p)
1276 error_e ret = ERROR_NONE;
1278 const char *passphrase = "gtest";
1279 char *enc_data = NULL;
1281 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1283 EXPECT_EQ(ERROR_NONE, ret);
1286 TEST(WifiTest, EncryptPassphrase_n)
1288 error_e ret = ERROR_NONE;
1290 const char *passphrase = "\0";
1291 char *enc_data = NULL;
1293 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1295 EXPECT_EQ(ERROR_NONE, ret);
1298 TEST(WifiTest, DecryptPassphrase_p)
1300 error_e ret = ERROR_NONE;
1303 const char *passphrase = "0123456789";
1304 char *enc_data = NULL;
1305 char *passphrase1 = NULL;
1307 ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1308 EXPECT_EQ(ERROR_NONE, ret);
1309 ret = mgr.DecryptPassphrase(enc_data, &passphrase1);
1310 std::cerr << "decrypted password = " << passphrase1;
1311 std::cerr << " " << "expected = " << passphrase << endl;
1312 EXPECT_EQ(!strcmp(passphrase1, passphrase), true);
1316 EXPECT_EQ(ERROR_NONE, ret);
1319 TEST(WifiTest, DecryptPassphrase_n)
1321 error_e ret = ERROR_NONE;
1323 char *passphrase = NULL;
1324 const char enc_data[] = "\0";
1326 ret = mgr.DecryptPassphrase(enc_data, &passphrase);
1328 EXPECT_NE(ERROR_NONE, ret);
1331 TEST(WifiTest, Stop_n)
1333 error_e ret = ERROR_NONE;
1336 ret = mgr.RemoveDriver();
1337 EXPECT_EQ(ERROR_NONE, ret);
1341 ret = mgr.Stop("gtest");
1342 EXPECT_NE(ERROR_NONE, ret);
1345 TEST(WifiTest, Start_p)
1347 error_e ret = ERROR_NONE;
1350 ret = mgr.Start("softap");
1351 EXPECT_EQ(ERROR_NONE, ret);
1354 TEST(WifiTest, Stop_p)
1356 error_e ret = ERROR_NONE;
1360 ret = mgr.Stop("softap");
1361 EXPECT_EQ(ERROR_NONE, ret);
1364 TEST(WifiTest, Start_n)
1366 error_e ret = ERROR_NONE;
1369 ret = mgr.Start("gtest");
1370 EXPECT_NE(ERROR_NONE, ret);
1373 int main(int argc, char **argv)
1375 InitGoogleTest(&argc, argv);
1376 return RUN_ALL_TESTS();