!6564 【communication】新增wifimanager JS L2测试用例

Merge pull request !6564 from 权力/myfeature

communication/wifi_p2p/src/main/js/test/List.test.js

@@ -13,8 +13,13 @@
  * limitations under the License.
  */
 import actsWifiFunctionTest from './WifiP2PFunction.test.js'
+import actsWifiManagerFunctionTest from './WifiManagerP2PFunction.test.js'
 import actsWifiEventTest from './WifiP2PEvent.test.js'
+import actsWifiManagerEventTest from './WifiManagerP2PEvent.test.js'
 export default function testsuite() {
-actsWifiFunctionTest()
-actsWifiEventTest()
+    actsWifiFunctionTest()
+    actsWifiManagerFunctionTest()
+    actsWifiEventTest()
+    actsWifiManagerEventTest()
 }
+

communication/wifi_p2p/src/main/js/test/WifiManagerP2PEvent.test.js

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from '@ohos/hypium'
+
+import wifiMg from '@ohos.wifiManager'
+
+function sleep(delay) {
+    return new Promise(resovle => setTimeout(resovle, delay))
+}
+
+function checkWifiPowerOn(){
+    console.info("[wifi_test]wifi status:" + wifiMg.isWifiActive());
+}
+
+let groupOwnerBand = {
+    GO_BAND_AUTO : 0,
+    GO_BAND_2GHZ : 1,
+    GO_BAND_5GHZ : 2,
+}
+
+export default function actsWifiManagerEventTest() {
+    describe('actsWifiManagerEventTest', function () {
+        beforeEach(function () {
+            console.info("[wifi_test]beforeEach start" );
+            checkWifiPowerOn();
+        })
+        afterEach(async function () {
+            console.info("[wifi_test]afterEach start" );
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0008
+        * @tc.name testp2pStateChange
+        * @tc.desc Test p2pStateChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0008', 0, async function (done) {
+            let p2pState = "p2pStateChange";
+            let p2pStateChangeCallback = result => {
+                console.info("[wifi_test]p2pStateChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pState, p2pStateChangeCallback);
+            await sleep(3000);
+            wifiMg.off(p2pState, p2pStateChangeCallback);
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0009
+        * @tc.name testp2pConnectionChange
+        * @tc.desc Test p2pConnectionChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0009', 0, async function (done) {
+            let p2pConnectionState = "p2pConnectionChange";
+            let p2pConnectionChangeCallback = result => {
+                console.info("[wifi_test]p2pConnectionChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pConnectionState, p2pConnectionChangeCallback);
+            let p2pConnectState = {
+                DISCONNECTED :0,
+                CONNECTED : 1,
+            };
+            let wifiP2PConfig = {
+                deviceAddress : "00:00:00:00:00:00",
+                netId : -1,
+                passphrase : "12345678",
+                groupName : "AAAZZZ456",
+                goBand : 0
+            };
+            let connectResult = wifiMg.p2pConnect(wifiP2PConfig);
+            await wifiMg.getP2pLinkedInfo()
+                .then(data => {
+                    let resultLength = Object.keys(data).length;
+                    console.info("[wifi_test]getP2pLinkedInfo  promise result : " + JSON.stringify(data));
+                    expect(true).assertEqual(resultLength!=0);
+                    done()
+                });
+            await sleep(2000);
+            wifiMg.off(p2pConnectionState, p2pConnectionChangeCallback);
+            let removeGroupResult = wifiMg.removeGroup();
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0012
+        * @tc.name testp2pDeviceChange
+        * @tc.desc Test p2pDeviceChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0012', 0, async function (done) {
+            let p2pDeviceState = "p2pDeviceChange";
+            let p2pDeviceChangeCallback = result => {
+                console.info("[wifi_test]p2pDeviceChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pDeviceState, p2pDeviceChangeCallback);
+            await sleep(3000);
+            wifiMg.off(p2pDeviceState, p2pDeviceChangeCallback);
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0010
+        * @tc.name testp2pPeerDeviceChange
+        * @tc.desc Test p2pPeerDeviceChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0010', 0, async function (done) {
+            let p2pPeerDeviceState = "p2pPeerDeviceChange";
+            let p2pPeerDeviceChangeCallback = result => {
+                console.info("[wifi_test]p2pPeerDeviceChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pPeerDeviceState, p2pPeerDeviceChangeCallback);
+            let startDiscover = wifiMg.startDiscoverDevices();
+            await sleep(3000);
+            let stopDiscover = wifiMg.stopDiscoverDevices();
+            wifiMg.off(p2pPeerDeviceState, p2pPeerDeviceChangeCallback);
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0013
+        * @tc.name testp2pPersistentGroupChange
+        * @tc.desc Test p2pPersistentGroupChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0013', 0, async function (done) {
+            let p2pGroupState = "p2pPersistentGroupChange";
+            let p2pPersistentGroupChangeCallback = () => {
+                console.info("[wifi_test]p2pPersistentGroupChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pGroupState, p2pPersistentGroupChangeCallback);
+            let WifiP2PConfig = {
+                deviceAddress : "00:00:00:00:00:00",
+                netId : -2,
+                passphrase : "12345678",
+                groupName : "AAAZZZ123",
+                goBand : 0,
+            };
+            let createGroupResult = wifiMg.createGroup(WifiP2PConfig);
+            await (2000);
+            await wifiMg.getCurrentGroup()
+                .then(data => {
+                    let resultLength = Object.keys(data).length;
+                    console.info("[wifi_test] getCurrentGroup  promise result -> " + JSON.stringify(data));
+                    expect(true).assertEqual(resultLength!=0);
+                });
+            wifiMg.off(p2pGroupState, p2pPersistentGroupChangeCallback);
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_Event_Test_0011
+        * @tc.name testpp2pDiscoveryChange
+        * @tc.desc Test p2pDiscoveryChange callback
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_Event_Test_0011', 0, async function (done) {
+            let p2pPeerDeviceState = "p2pDiscoveryChange";
+            let p2pDiscoveryChangeCallback = result => {
+                console.info("[wifi_test]p2pDiscoveryChange callback, result: " + JSON.stringify(result));
+            }
+            wifiMg.on(p2pPeerDeviceState, p2pDiscoveryChangeCallback);
+            let startDiscover = wifiMg.startDiscoverDevices();
+            await sleep(3000);
+            let stopDiscover = wifiMg.stopDiscoverDevices();
+            wifiMg.off(p2pPeerDeviceState, p2pDiscoveryChangeCallback);
+            done();
+        })
+        console.log("*************[wifi_test] start wifi js unit test end*************");
+    })
+}
+

communication/wifi_standard/src/main/js/test/List.test.js

@@ -13,12 +13,17 @@
  * limitations under the License.
  */
 import actsWifiCandidateNetWorkTest from './WifiCandidateNetWork.test.js'
+import actsWifiManagerCandidateNetWorkTest from './WifiManagerCandidateNetWork.test.js'
 import actsWifiFunctionsTest from './WifiStationFunctions.test.js'
+import actsWifiManagerFunctionsTest from './WifiManagerStationFunctions.test.js'
 import actsWifiEventTest from './WifiStationEvent.test.js'
+import actsWifiManagerEventTest from './WifiManagerStationEvent.test.js'
 export default function testsuite() {
-actsWifiCandidateNetWorkTest()
-actsWifiFunctionsTest()
-actsWifiEventTest()
+    actsWifiCandidateNetWorkTest()
+    actsWifiManagerCandidateNetWorkTest()
+    actsWifiFunctionsTest()
+    actsWifiManagerFunctionsTest()
+    actsWifiEventTest()
+    actsWifiManagerEventTest()
 }
 
-

communication/wifi_standard/src/main/js/test/WifiCandidateNetWork.test.js

@@ -93,10 +93,8 @@ export default function actsWifiCandidateNetWorkTest() {
                     console.error('[wifi_test]add OPEN CandidateConfig promise failed -> ' + JSON.stringify(error));
                     expect(false).assertFalse();
                 });
-
             let getconfig = wifi.getCandidateConfigs();
             console.info("[wifi_test]wifi get OPEN CandidateConfigs result : " + JSON.stringify(getconfig));
-
             let wifiDeviceConfig1 = {
                 "ssid": "TEST_WEP",
                 "bssid": "",
@@ -104,7 +102,6 @@ export default function actsWifiCandidateNetWorkTest() {
                 "isHiddenSsid": false,
                 "securityType": wifiSecurityType.WIFI_SEC_TYPE_WEP,
             };
-
             await wifi.addCandidateConfig(wifiDeviceConfig1)
                 .then(netWorkId => {
                     console.info("[wifi_test]add WEP CandidateConfig promise : " + JSON.stringify(netWorkId));
@@ -154,7 +151,6 @@ export default function actsWifiCandidateNetWorkTest() {
             await wifi.removeCandidateConfig(networkId)
                 .then(ret => {
                     console.info("[wifi_test]remove CandidateConfig promise:" + JSON.stringify(ret));
-                    expect(false).assertFalse();
                     let getCandidate = wifi.getCandidateConfigs();
                     console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getCandidate));
                     console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getCandidate.length));
@@ -195,7 +191,6 @@ export default function actsWifiCandidateNetWorkTest() {
             await wifi.removeCandidateConfig(networkId)
                 .then(ret => {
                     console.info("[wifi_test]remove CandidateConfig promise" + JSON.stringify(ret));
-                    expect(false).assertFalse();
                     let getconfig1 = wifi.getCandidateConfigs();
                     console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getconfig1));
                     console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getconfig1.length));
@@ -339,7 +334,7 @@ export default function actsWifiCandidateNetWorkTest() {
                 WIFI_SEC_TYPE_SAE: 4,
             }
             let wifiDeviceConfig = {
-                "ssid": "HONOR 3000",
+                "ssid": "TEST_connect",
                 "bssid": "",
                 "preSharedKey": "12345678",
                 "isHiddenSsid": false,
@@ -354,7 +349,7 @@ export default function actsWifiCandidateNetWorkTest() {
                     expect().assertFail();
                 });
             let getCandidateResult = wifi.getCandidateConfigs();
-            console.info("[wifi_test]wifi get  CandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getCandidateResult));
             let connectToCandidateResult = wifi.connectToCandidateConfig(getCandidateResult[0].netId);
             console.info("[wifi_test]connect To CandidateConfig result : " + JSON.stringify(connectToCandidateResult));
             await sleep(3000);
@@ -366,6 +361,20 @@ export default function actsWifiCandidateNetWorkTest() {
                     console.info("[wifi_test]promise then error." + JSON.stringify(error));
                     expect().assertFail();
                 });
+            let getCandidateResult1 = wifi.getCandidateConfigs();
+            console.info("[wifi_test]wifi get CandidateConfigs result1 : " + JSON.stringify(getCandidateResult1));
+            var networkId = getCandidateResult1[0].netId;
+            console.info("[wifi_test]wifi get networkId result : " + JSON.stringify(networkId));
+            await wifi.removeCandidateConfig(networkId)
+                .then(ret => {
+                    let getconfig1 = wifi.getCandidateConfigs();
+                    console.info("[wifi_test]wifi get CandidateConfigs result2 : " + JSON.stringify(getconfig1));
+                    console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getconfig1.length));
+                    expect(true).assertEqual(getconfig1.length == 0);
+                }).catch((error) => {
+                    console.error('[wifi_test]remove CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
             done();
         })
 

communication/wifi_standard/src/main/js/test/WifiManagerCandidateNetWork.test.js

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from '@ohos/hypium'
+
+import wifiMg from '@ohos.wifiManager'
+
+function sleep(delay) {
+    return new Promise(resovle => setTimeout(resovle, delay))
+}
+
+function checkWifiPowerOn(){
+    console.info("[wifi_test]wifi status:" + wifiMg.isWifiActive());
+}
+
+function resolveIP(ip) {
+    return (ip>>24 & 0xFF) + "." + (ip>>16 & 0xFF) + "." + (ip>>8 & 0xFF) + "." + (ip & 0xFF);
+}
+
+let wifiSecurityType = {
+    WIFI_SEC_TYPE_INVALID: 0,
+    WIFI_SEC_TYPE_OPEN: 1,
+    WIFI_SEC_TYPE_WEP: 2,
+    WIFI_SEC_TYPE_PSK: 3,
+    WIFI_SEC_TYPE_SAE: 4,
+    WIFI_SEC_TYPE_EAP: 5,
+    WIFI_SEC_TYPE_EAP_SUITE_B: 6,
+    WIFI_SEC_TYPE_OWE:7 ,
+    WIFI_SEC_TYPE_WAPI_CERT:8 ,
+    WIFI_SEC_TYPE_WAPI_PSK:9 ,
+}
+
+let connState = {
+    SCANNING: 0,
+    CONNECTING: 1,
+    AUTHENTICATING: 2,
+    OBTAINING_IPADDR: 3,
+    CONNECTED: 4,
+    DISCONNECTING: 5,
+    DISCONNECTED: 6,
+    UNKNOWN: 7,
+}
+
+let wifiChannelWidth = {
+    WIDTH_20MHZ : 0,
+    WIDTH_40MHZ : 1,
+    WIDTH_80MHZ : 2,
+    WIDTH_160MHZ : 3,
+    WIDTH_80MHZ_PLUS : 4,
+    WIDTH_INVALID:null,
+}
+
+export default function actsWifiManagerCandidateNetWorkTest() {
+    describe('actsWifiManagerCandidateNetWorkTest', function () {
+        beforeEach(function () {
+            checkWifiPowerOn();
+        })
+        afterEach(function () {
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0001
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test add OPEN and WEP CandidateConfig Promise API functionality.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0001', 0, async function (done) {
+            let wifiDeviceConfig = {
+                "ssid": "TEST_OPEN",
+                "bssid": "",
+                "preSharedKey": "",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_OPEN,
+            };
+            await wifiMg.addCandidateConfig(wifiDeviceConfig)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add OPEN CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId = -1);
+                }).catch((error) => {
+                    console.error('[wifi_test]add OPEN CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect(false).assertFalse();
+                });
+            let getconfig = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get OPEN CandidateConfigs result : " + JSON.stringify(getconfig));
+            let wifiDeviceConfig1 = {
+                "ssid": "TEST_WEP",
+                "bssid": "",
+                "preSharedKey": "ABCDEF1234",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_WEP,
+            };
+
+            await wifiMg.addCandidateConfig(wifiDeviceConfig1)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add WEP CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId = -1);
+                }).catch((error) => {
+                    console.error('[wifi_test]add WEP CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect(false).assertFalse();
+                });
+            console.info("[wifi_test]wifi get WEP CandidateConfigs result : " + JSON.stringify(getconfig));
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0002
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test add PSK CandidateConfig and removeCandidateConfig Promise API functionality.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0002', 0, async function (done) {
+            let wifiDeviceConfig = {
+                "ssid": "TEST_PSK",
+                "bssid": "",
+                "preSharedKey": "12345678",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK,
+                "netId": -1,
+                "ipType": 1,
+                "creatorUid": 7,
+                "disableReason": 0,
+                "randomMacType": 0,
+                "randomMacAddr": "11:22:33:44:55:66",
+                "staticIp": {"ipAddress": 1284752956,"gateway": 1284752936},
+            };
+            await wifiMg.addCandidateConfig(wifiDeviceConfig)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add PSK CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId != -1);
+                }).catch((error) => {
+                    console.error('[wifi_test]add PSK CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            let getCandidateResult = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get PSK CandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            var networkId = getCandidateResult[0].netId;
+            console.info("[wifi_test]wifi get networkId result : " + JSON.stringify(networkId));
+            await wifiMg.removeCandidateConfig(networkId)
+                .then(ret => {
+                    let getCandidate = wifiMg.getCandidateConfigs();
+                    console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getCandidate));
+                    console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getCandidate.length));
+                    expect(true).assertEqual(getCandidate.length == 0);
+                }).catch((error) => {
+                    console.error('[wifi_test]remove CandidateConfig promise failed ： ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0003
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test add SAE CandidateConfig Promise API functionality.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0003', 0, async function (done) {
+            let wifiDeviceConfig = {
+                "ssid": "TEST_SAE",
+                "bssid": "",
+                "preSharedKey": "12345678",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_SAE,
+            };
+            await wifiMg.addCandidateConfig(wifiDeviceConfig)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add SAE CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId != -1);
+                }).catch((error) => {
+                    console.error('[wifi_js]add SAE CandidateConfig promise failed -> ' + JSON.stringify(error));
+                });
+            let getCandidateResult = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get SAE CandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            var networkId = getCandidateResult[0].netId;
+            console.info("[wifi_test]wifi get networkId result : " + JSON.stringify(networkId));
+            await wifiMg.removeCandidateConfig(networkId)
+                .then(ret => {
+                    let getconfig1 = wifiMg.getCandidateConfigs();
+                    console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getconfig1));
+                    console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getconfig1.length));
+                    expect(true).assertEqual(getconfig1.length == 0);
+                }).catch((error) => {
+                    console.error('[wifi_test]remove CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0004
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test add MAX CandidateConfig and removeall CandidateConfig.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0004', 0, async function (done) {
+            let SSID = "TYPE_PSK"
+            for (let i = 0; i < 16; i++) {
+                SSID = "TYPE_PSK" + i
+                console.info("[wifi_test] get canshu result : ");
+                let wifiDeviceConfig = {
+                    "ssid": SSID,
+                    "bssid": "",
+                    "preSharedKey": "12345678",
+                    "isHiddenSsid": false,
+                    "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK,
+                };
+                console.info("[wifi_test]get wifiDeviceConfig ssid result : " + JSON.stringify(wifiDeviceConfig.ssid));
+                await wifiMg.addCandidateConfig(wifiDeviceConfig)
+                    .then(netWorkId => {
+                        console.info("[wifi_test]add 16th CandidateConfig promise : " + JSON.stringify(netWorkId));
+                        expect(true).assertEqual(netWorkId != -1);
+                    }).catch((error) => {
+                        console.error('[wifi_test]add 16th CandidateConfig promise failed ：' + JSON.stringify(error));
+                        expect().assertFail();
+                    });
+            }
+            let wifiDeviceConfig1 = {
+                "ssid": "TYPE_17",
+                "bssid": "",
+                "preSharedKey": "12345678",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK,
+            };
+            await wifiMg.addCandidateConfig(wifiDeviceConfig1)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add 17th CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId != -1);
+                }).catch((error) => {
+                    console.error(`[wifi_test]add 17th failed, code is ${error.code}, message is ${error.message}`);
+                    expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
+                });
+            let getCandidateResult = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get 16 CandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            for (let i = 0; i < 16; i++) {
+                var networkId = getCandidateResult[i].netId;
+                console.info("[wifi_test]wifi get networkId result : " + JSON.stringify(networkId));
+                await wifiMg.removeCandidateConfig(networkId)
+                    .then(ret => {
+                        let getconfig1 = wifiMg.getCandidateConfigs();
+                        console.info("[wifi_test] wifi get CandidateConfigs result : " + JSON.stringify(getconfig1));
+                        console.info("[wifi_test] wifi getconfiglength result : " + JSON.stringify(getconfig1.length));
+                    }).catch((error) => {
+                        console.error('[wifi_test]remove CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    });
+            }
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0005
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test add CandidateConfig and removeCandidateConfig callback API functionality.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0005', 0, async function (done) {
+            let wifiDeviceConfig = {
+                "ssid": "TEST_connect",
+                "bssid": "",
+                "preSharedKey": "12345678",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK,
+            }
+            function addCandidate() {
+                return new Promise((resolve, reject) => {
+                    wifiMg.addCandidateConfig(wifiDeviceConfig,
+                        (err, netWorkId) => {
+                            if (err) {
+                                console.info("[wifi_test]add CandidateConfig callback failed : " + JSON.stringify(err));
+                            }
+                            console.info("[wifi_test]addCandidateConfig callback result: " + JSON.stringify(netWorkId));
+                            expect(true).assertEqual(netWorkId != -1);
+                            resolve();
+                        });
+                });
+            }
+            await addCandidate();
+            let getCandidateResult = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test] wifi getCandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            var networkId = getCandidateResult[0].netId;
+            function removeCandidate() {
+                return new Promise((resolve, reject) => {
+                    wifiMg.removeCandidateConfig(networkId,
+                        (err, ret) => {
+                            if (err) {
+                                console.info("[wifi_test]removeCandidate callback failed : " + JSON.stringify(err));
+                            }
+                            let configs1 = wifiMg.getCandidateConfigs();
+                            console.info("[wifi_test] wifi get  CandidateConfigs result : " + JSON.stringify(configs1));
+                            console.info("[wifi_test] getconfig.length result : " + JSON.stringify(configs1.length));
+                            expect(true).assertEqual(configs1.length == 0);
+                            resolve();
+                        });
+                });
+            }
+            await removeCandidate();
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_CandidateNetWork_0006
+        * @tc.name testaddCandidateConfig
+        * @tc.desc Test connect To CandidateConfig API functionality.
+        * @tc.type Function
+        * @tc.level Level 2
+        */
+        it('SUB_Communication_WiFi_XTS_CandidateNetWork_0006', 0, async function (done) {
+            let wifiSecurityType = {
+                WIFI_SEC_TYPE_INVALID: 0,
+                WIFI_SEC_TYPE_OPEN: 1,
+                WIFI_SEC_TYPE_WEP: 2,
+                WIFI_SEC_TYPE_PSK: 3,
+                WIFI_SEC_TYPE_SAE: 4,
+            }
+            let wifiDeviceConfig = {
+                "ssid": "HONOR 3000",
+                "bssid": "",
+                "preSharedKey": "12345678",
+                "isHiddenSsid": false,
+                "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK,
+            };
+            await wifiMg.addCandidateConfig(wifiDeviceConfig)
+                .then(netWorkId => {
+                    console.info("[wifi_test]add CandidateConfig promise : " + JSON.stringify(netWorkId));
+                    expect(true).assertEqual(netWorkId != -1);
+                }).catch((error) => {
+                    console.error('[wifi_test]add CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            let getCandidateResult = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get  CandidateConfigs result : " + JSON.stringify(getCandidateResult));
+            let connectToCandidateResult = wifiMg.connectToCandidateConfig(getCandidateResult[0].netId);
+            await sleep(3000);
+            await wifiMg.getLinkedInfo()
+                .then((result) => {
+                    console.info("[wifi_test]get wifi link [promise] -> " + JSON.stringify(result));
+                    done();
+                }).catch((error) => {
+                    console.info("[wifi_test]promise then error." + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            let getCandidateResult1 = wifiMg.getCandidateConfigs();
+            console.info("[wifi_test]wifi get CandidateConfigs result1 : " + JSON.stringify(getCandidateResult1));
+            var networkId = getCandidateResult1[0].netId;
+            console.info("[wifi_test]wifi get networkId result : " + JSON.stringify(networkId));
+            await wifiMg.removeCandidateConfig(networkId)
+                .then(ret => {
+                    let getconfig1 = wifiMg.getCandidateConfigs();
+                    console.info("[wifi_test]wifi get CandidateConfigs result : " + JSON.stringify(getconfig1));
+                    console.info("[wifi_test]wifi  getconfig.length result : " + JSON.stringify(getconfig1.length));
+                    expect(true).assertEqual(getconfig1.length == 0);
+                }).catch((error) => {
+                    console.error('[wifi_test]remove CandidateConfig promise failed -> ' + JSON.stringify(error));
+                    expect().assertFail();
+                });
+            done();
+        })
+    })
+}
+

communication/wifi_standard/src/main/js/test/WifiManagerStationFunctions.test.js

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'
+
+import wifiMg from '@ohos.wifiManager'
+
+function sleep(delay) {
+    return new Promise(resovle => setTimeout(resovle, delay))
+}
+
+function checkWifiPowerOn(){
+    console.info("[wifi_test]wifi status:" + wifiMg.isWifiActive());
+}
+
+function resolveIP(ip) {
+    return (ip>>24 & 0xFF) + "." + (ip>>16 & 0xFF) + "." + (ip>>8 & 0xFF) + "." + (ip & 0xFF);
+}
+
+let wifiSecurityType = {
+    WIFI_SEC_TYPE_INVALID: 0,
+    WIFI_SEC_TYPE_OPEN: 1,
+    WIFI_SEC_TYPE_WEP: 2,
+    WIFI_SEC_TYPE_PSK: 3,
+    WIFI_SEC_TYPE_SAE: 4,
+    WIFI_SEC_TYPE_EAP: 5,
+    WIFI_SEC_TYPE_EAP_SUITE_B: 6,
+    WIFI_SEC_TYPE_OWE:7 ,
+    WIFI_SEC_TYPE_WAPI_CERT:8 ,
+    WIFI_SEC_TYPE_WAPI_PSK:9 ,
+}
+
+let connState = {
+    SCANNING: 0,
+    CONNECTING: 1,
+    AUTHENTICATING: 2,
+    OBTAINING_IPADDR: 3,
+    CONNECTED: 4,
+    DISCONNECTING: 5,
+    DISCONNECTED: 6,
+    UNKNOWN: 7,
+}
+
+let untrustedDeviceConfig = {
+    "ssid": "untrusted_ssid",
+    "bssid": "",
+    "preSharedKey": "12345678",
+    "isHiddenSsid": false,
+    "securityType": wifiSecurityType.WIFI_SEC_TYPE_PSK
+}
+
+let wifiChannelWidth = {
+    WIDTH_20MHZ : 0,
+    WIDTH_40MHZ : 1,
+    WIDTH_80MHZ : 2,
+    WIDTH_160MHZ : 3,
+    WIDTH_80MHZ_PLUS : 4,
+    WIDTH_INVALID:null,
+}
+
+export default function actsWifiManagerFunctionsTest() {
+    describe('actsWifiManagerFunctionsTest', function() {
+        beforeEach(function () {
+            checkWifiPowerOn();
+        })
+        afterEach(function () {
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0002
+        * @tc.name testgetScanResults
+        * @tc.desc Test getScanResults promise and callback API functionality.
+        * @tc.type Function
+        * @tc.level Level 0
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0002', 0, async function (done) {
+            let scanResult = wifiMg.scan();
+            await sleep(3000);
+            await wifiMg.getScanResults()
+                .then(result => {
+                    let clen = Object.keys(result).length;
+                    expect(true).assertEqual(clen >= 0);
+                    console.info("[wifi_test]getScanInfos promise result:" + JSON.stringify(result));
+                });
+            function getScan() {
+                return new Promise((resolve, reject) => {
+                    wifiMg.getScanResults(
+                        (err, result) => {
+                            if (err) {
+                                console.log("[wifi_test] wifi getScanInfos failed:" + err);
+                            }
+                            let clen = Object.keys(result).length;
+                            if (!(clen == 0)) {
+                                expect(clen).assertLarger(0);
+                                console.info("[wifi_test] getScanInfos callback result: " + JSON.stringify(result));
+                                for (let j = 0; j < clen; ++j) {
+                                    console.info("ssid: " + result[j].ssid + "bssid: " + result[j].bssid +
+                                    "securityType: " + result[j].securityType +
+                                    "rssi: " + result[j].rssi + "band: " + result[j].band +
+                                    "frequency: " + result[j].frequency + "channelWidth: " + result[j].channelWidth +
+                                    "timestamp" + result[j].timestamp + "capabilities" + result[j].capabilities
+                                    + "centerFrequency0: " + result[j].centerFrequency0
+                                    + "centerFrequency1: " + result[j].centerFrequency1
+                                    + "eid: " + result[j].infoElems.eid + "content: " + result[j].infoElems.content);
+                                }
+                            }
+                            resolve();
+                        });
+                });
+            }
+            await getScan();
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0021
+        * @tc.name testGetSignalLevel
+        * @tc.desc Test getSignalLevel API functionality..
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0021', 0, function () {
+            console.info("[wifi_test] check the 2.4G rssi assgined to level test.");
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-65, 1));
+            expect(wifiMg.getSignalLevel(-65, 1)).assertEqual(4);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-66, 1));
+            expect(wifiMg.getSignalLevel(-66, 1)).assertEqual(3);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-75, 1));
+            expect(wifiMg.getSignalLevel(-75, 1)).assertEqual(3);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-76, 1));
+            expect(wifiMg.getSignalLevel(-76, 1)).assertEqual(2);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-82, 1));
+            expect(wifiMg.getSignalLevel(-82, 1)).assertEqual(2);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-83, 1));
+            expect(wifiMg.getSignalLevel(-83, 1)).assertEqual(1);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-88, 1));
+            expect(wifiMg.getSignalLevel(-88, 1)).assertEqual(1);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-89, 1));
+            expect(wifiMg.getSignalLevel(-89, 1)).assertEqual(0);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-127, 1));
+            expect(wifiMg.getSignalLevel(-127, 1)).assertEqual(0);
+
+            console.info("[wifi_test] check the 5G rssi assgined to level test.");
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-65, 2));
+            expect(wifiMg.getSignalLevel(-65, 2)).assertEqual(4);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-66, 2));
+            expect(wifiMg.getSignalLevel(-66, 2)).assertEqual(3);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-72, 2));
+            expect(wifiMg.getSignalLevel(-72, 2)).assertEqual(3);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-73, 2));
+            expect(wifiMg.getSignalLevel(-73, 2)).assertEqual(2);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-79, 2));
+            expect(wifiMg.getSignalLevel(-79, 2)).assertEqual(2);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-80, 2));
+            expect(wifiMg.getSignalLevel(-80, 2)).assertEqual(1);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-85, 2));
+            expect(wifiMg.getSignalLevel(-85, 2)).assertEqual(1);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-86, 2));
+            expect(wifiMg.getSignalLevel(-86, 2)).assertEqual(0);
+            console.info("[wifi_test] getSignalLevel " + wifiMg.getSignalLevel(-127, 2));
+            expect(wifiMg.getSignalLevel(-127, 2)).assertEqual(0);
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0017
+        * @tc.name testgetCountryCode
+        * @tc.desc Test getCountryCode API function.
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0017', 0, function () {
+            expect(wifiMg.isWifiActive()).assertTrue();
+            let getCountryCodeResult = wifiMg.getCountryCode();
+            console.info("[wifi_test]getCountryCode :" + JSON.stringify(getCountryCodeResult));
+            let countrylenth = getCountryCodeResult.length;
+            console.info("[wifi_test]getCountryCode.length :" + JSON.stringify(countrylenth));
+            expect(true).assertEqual(countrylenth == 2);
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0020
+        * @tc.name testFeatureSupported
+        * @tc.desc Test FeatureSupported API function.
+        * @tc.type Function
+        * @tc.level Level 3
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0020', 0, function () {
+            expect(wifiMg.isWifiActive()).assertTrue();
+            let wifiUtils = {
+                WIFI_FEATURE_INFRA: 0x0001,
+                WIFI_FEATURE_INFRA_5G: 0x0002,
+                WIFI_GAS_ANQP: 0x0004,
+                WIFI_WIFI_DIRECT: 0x0008,
+                WIFI_FEATURE_MOBILE_HOTSPOT: 0x0010,
+                WIFI_FEATURE_AWARE: 0x0040,
+                WIFI_FEATURE_AP_STA: 0x8000,
+                WIFI_FEATURE_WPA3_SAE: 0x8000000,
+                WIFI_FEATURE_WPA3_SUITE_B: 0x10000000,
+                WIFI_FEATURE_OWE: 0x20000000
+            }
+            let isSupport1 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_INFRA);
+            console.info("[wifi_test] isFeatureSupported -> " + isSupport1);
+            let isSupport2 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_INFRA_5G);
+            console.info("[wifi_test] isFeatureSupported2 -> " + isSupport2);
+            let isSupport3 = wifiMg.isFeatureSupported(wifiUtils.WIFI_GAS_ANQP);
+            console.info("[wifi_test] isFeatureSupported3 -> " + isSupport3);
+            let isSupport4 = wifiMg.isFeatureSupported(wifiUtils.WIFI_WIFI_DIRECT);
+            console.info("[wifi_test] isFeatureSupported4 -> " + isSupport4);
+            let isSupport5 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_MOBILE_HOTSPOT);
+            console.info("[wifi_test] isFeatureSupported5 -> " + isSupport5);
+            let isSupport6 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_AWARE);
+            console.info("[wifi_test] isFeatureSupported6 -> " + isSupport6);
+            let isSupport7 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_AP_STA);
+            console.info("[wifi_test] isFeatureSupported7 -> " + isSupport7);
+            let isSupport8 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_WPA3_SAE);
+            console.info("[wifi_test] isFeatureSupported8 -> " + isSupport8);
+            let isSupport9 = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_WPA3_SUITE_B);
+            console.info("[wifi_test] isFeatureSupported9 -> " + isSupport9);
+            let isSupport = wifiMg.isFeatureSupported(wifiUtils.WIFI_FEATURE_OWE);
+            console.info("[wifi_test] isFeatureSupported -> " + isSupport);
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0004
+        * @tc.name testGetLinkedInfo
+        * @tc.desc Test Test getLinkedInfo and getIpInfo  information.
+        * @tc.type Function
+        * @tc.level Level 1
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0004', 0, async function (done) {
+            let isConnectedResult = wifiMg.isConnected();
+            let ipInfoResult = wifiMg.getIpInfo();
+            expect(JSON.stringify(ipInfoResult)).assertContain("gateway");
+            let ipAddress = resolveIP(ipInfoResult.ipAddress);
+            console.info("[wifi_test]ipAddress result: " + ipAddress);
+            console.info("gateway: " + ipInfoResult.gateway + "ipAddress: " + ipInfoResult.ipAddress
+            + "leaseDuration: " + ipInfoResult.leaseDuration +
+            "leaseDuration: " + ipInfoResult.leaseDuration +
+            "netmask: " + ipInfoResult.netmask + "primaryDns:" + ipInfoResult.primaryDns +
+            "secondDns: " + ipInfoResult.secondDns + "serverIp: " + ipInfoResult.serverIp);
+            await wifiMg.getLinkedInfo()
+                .then((result) => {
+                    console.info("[wifi_test]get wifi link promise:" + JSON.stringify(result));
+                    done();
+                }).catch((error) => {
+                    console.info("[wifi_test]promise then error." + JSON.stringify(error));
+                    expect().assertFail();
+                });
+
+            function getLinked(){
+                return new Promise((resolve, reject) => {
+                    wifiMg.getLinkedInfo(
+                        (err, result) => {
+                            if(err) {
+                                console.log("[wifi_test]wifi getLinkedInfo failed " + err);
+                            }
+                            let clen = Object.keys(result).length;
+                            expect(clen).assertLarger(0);
+                            console.info("[wifi_test]getLinkedInfo callback result: " + JSON.stringify(result));
+                            console.info("ssid: " + result.ssid + "bssid:" + result.bssid + "band: " + result.band +
+                            "isHidden: " + result.isHidden + "isRestricted: " + result.isRestricted +
+                            "chload: " + result.chload + "rssi " + result.rssi + "netWorkId: " + result.netWorkId +
+                            "linkSpeed: " + result.linkSpeed + "frequency:"
+                            + result.frequency + "snr:" + result.snr +
+                            "macAddress: " + result.macAddress + "ipAddress: " + result.ipAddress +
+                            "suppState: " + result.suppState + "connState: " + result.connState
+                            + "macType: " + result.macType);
+                            let state = wifiMg.getLinkedInfo().ConnState;
+                            if (state == connState.SCANNING) {
+                                expect(true).assertEqual(state == 0);
+                            }
+                            if (state == connState.CONNECTING) {
+                                expect(true).assertEqual(state == 1);
+                            }
+                            if (state == connState.AUTHENTICATING) {
+                                expect(true).assertEqual(state == 2);
+                            }
+                            if (state == connState.OBTAINING_IPADDR) {
+                                expect(true).assertEqual(state == 3);
+                            }
+                            if (state == connState.CONNECTED) {
+                                expect(true).assertEqual(state == 4);
+                            }
+                            if (state == connState.DISCONNECTING) {
+                                expect(true).assertEqual(state == 5);
+                            }
+                            if (state == connState.DISCONNECTED) {
+                                expect(true).assertEqual(state == 6);
+                            }
+                            if (state == connState.UNKNOWN) {
+                                expect(true).assertEqual(state == 7);
+                            }
+                            resolve();
+                        });
+                });
+            }
+            await getLinked();
+            done();
+        })
+
+        /**
+        * @tc.number SUB_Communication_WiFi_XTS_Sta_0034
+        * @tc.name testgetScanResultsSync
+        * @tc.desc Test getScanResults Sync API functionality.
+        * @tc.type Function
+        * @tc.level Level 0
+        */
+        it('SUB_Communication_WiFi_XTS_Sta_0034', 0, async function (done) {
+            let getScanResultsResult = wifiMg.getScanResultsSync();
+            console.info("[wifi_test]wifi getScanResultsSync  result : " + JSON.stringify(getScanResultsResult));
+            let scanInfolenth = Object.keys(getScanResultsResult).length;
+            console.info("[wifi_test]wifi ScanInfosSync length  result : " + JSON.stringify(scanInfolenth));
+            expect(true).assertEqual(scanInfolenth >= 0);
+            done();
+        })
+        console.log("*************[wifi_test] start wifi js unit test end*************");
+        })
+}
+