quanli1@huawei.com

Signed-off-by: N quanli <quanli1@huawei.com>

quanli1@huawei.com
Signed-off-by: N quanli <quanli1@huawei.com>
9c63cd4c · quanli · 5e7e4e7c · 9c63cd4c · 9c63cd4c · 9c63cd4c
5 changed file
--- a/communication/wifi_p2p/src/main/js/test/WifiManagerP2PEvent.test.js
+++ b/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());
 }
 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 : wifiMg.GroupOwnerBand.GO_BAND_AUTO,
            };
            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 : wifiMg.GroupOwnerBand.GO_BAND_AUTO,
            };
            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*************");
    })
 }
--- a/communication/wifi_p2p/src/main/js/test/WifiManagerP2PFunction.test.js
+++ b/communication/wifi_p2p/src/main/js/test/WifiManagerP2PFunction.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());
 }
 export default function actsWifiManagerFunctionTest() {
    describe('actsWifiManagerFunctionTest', function () {
        beforeEach(function () {
            console.info("[wifi_test]beforeEach start" );
            checkWifiPowerOn();
        })
        afterEach(async function () {
            console.info("[wifi_test]afterEach start" );
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0003
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup and getCurrentGroup API Function
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0003', 0, async function(done) {
            let wifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -1,
                passphrase : "12345678",
                groupName : "AAAZZZ123",
                goBand : wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup promise result -> " + JSON.stringify(data));
                    expect(true).assertEqual(data.groupName == wifiP2PConfig.groupName);
                });
            function getCurrentGroupResult(){
                return new Promise((resolve, reject) => {
                    wifiMg.getCurrentGroup(
                        (err, result) => {
                            if(err) {
                                console.info("[wifi_test]failed to get getCurrentGroup:" + JSON.stringify(err));
                                expect().assertFail();
                            }
                            console.info("[wifi_test]getCurrentGroup callback:" + JSON.stringify(result));
                            console.info("isP2pGo: " + result.isP2pGo +
                            "deviceName: " + result.ownerInfo.deviceName +
                            "deviceAddress: " + result.ownerInfo.deviceAddress +
                            "primaryDeviceType: " + result.ownerInfo.primaryDeviceType +
                            "deviceStatus: " + result.ownerInfo.deviceStatus +
                            "groupCapabilitys: " + result.ownerInfo.groupCapabilitys +
                            "passphrase: " + result.passphrase + "interface: "+ result.interface
                            + "groupName: " + result.groupName +
                            "frequency: " + result.frequency + "goIpAddress: " + result.goIpAddress);
                            console.info("[wifi_test] clientDevices:" + JSON.stringify(result.clientDevices));
                            console.info("[wifi_test] ownerInfo:" + JSON.stringify(result.WifiP2pDevice));
                            resolve();
                        });
                });
            }
            await getCurrentGroupResult();
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0004
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Setting a 7-bit Key Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0004', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "1234567",
                groupName: "test_pass",
                goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.networkId == -999);
                });
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0104
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting: Chinese, English, and characters Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0104', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "123@%abcD",
                groupName: "test_pass1",
                goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result : " + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase == wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0204
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting 64 bit Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0204', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "abc345678901234567890123456789012345678901234567890123456789012",
                groupName: "test_pass2",
                goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup promise result : " + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase == wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0304
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting 65 bitsFunction.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0304', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "abc3456789012345678901234567890123456789012345678901234567890123",
                groupName: "test_pass3",
                goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase != wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0007
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-2.4 GHz frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0007', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -1,
                passphrase : "12345678",
                groupName : "test_band1",
                goBand : wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(2412 < data.frequency < 2484 );
                });
            let removeGroupResult = wifiMg.removeGroup();
            await sleep(2000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0107
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-5 GHz frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0107', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress : "00:00:00:00:00:00",
                    netId : -1,
                    passphrase : "12345678",
                    groupName : "test_band2",
                    goBand : wifiMg.GroupOwnerBand.GO_BAND_5GHZ,
                };
                let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
                await sleep(2000);
                await wifiMg.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                        expect(true).assertEqual(5160 < data.frequency < 5865);
                    });
                let removeGroupResult = await wifiMg.removeGroup();
                await sleep(2000);
                await wifiMg.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup 5G goBand result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0207
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Auto frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0207', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress : "00:00:00:00:00:00",
                    netId : -1,
                    passphrase : "12345678",
                    groupName : "test_band3",
                    goBand : wifiMg.GroupOwnerBand.GO_BAND_AUTO,
                };
                let createGroupResult = wifiMg.createGroup(wifiP2PConfig);
                await sleep(2000);
                await wifiMg.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test]getCurrentGroup promise result : " + JSON.stringify(data));
                        expect(true).assertEqual(data.frequency != null );
                    });
                let removeGroupResult = await wifiMg.removeGroup();
                await sleep(2000);
                await wifiMg.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup auto  goBand result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0008
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-SSID is an empty string Function.
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0008', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress: "00:00:00:00:00:00",
                    netId: -1,
                    passphrase: "12345678",
                    groupName: "",
                    goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
                };
                let createGroupResult = wifi.createGroup(wifiP2PConfig);
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test]getCurrentGroup  promise result : " + JSON.stringify(data));
                    });
                let removeGroupResult = wifi.removeGroup();
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup error passphrase result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0108
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-SSID is a space Function.
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0108', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress: "00:00:00:00:00:00",
                    netId: -1,
                    passphrase: "12345678",
                    groupName: " ",
                    goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
                };
                let createGroupResult = wifi.createGroup(wifiP2PConfig);
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test]getCurrentGroup promise result :" + JSON.stringify(data));
                    });
                let removeGroupResult = wifi.removeGroup();
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup error passphrase result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
       * @tc.number SUB_Communication_WiFi_XTS_P2P_0308
       * @tc.name testCreateGroup
       * @tc.desc Test createGroup-the password must be a space.
       * @tc.type Function
       * @tc.level Level 0
       */
        it('SUB_Communication_WiFi_XTS_P2P_0308', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress: "00:00:00:00:00:00",
                    netId: -1,
                    passphrase: " ",
                    groupName: "testpassword",
                    goBand: wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
                };
                let createGroupResult = wifi.createGroup(wifiP2PConfig);
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                    });
                let removeGroupResult = wifi.removeGroup();
                await sleep(2000);
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup error passphrase result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0009
        * @tc.name testP2pCancelConnect
        * @tc.desc Test p2pCancelConnect Group API functionality.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0009', 0, async function (done) {
            let wifiP2PConfig = {
                deviceAddress : "11:22:33:44:55:66",
                netId : -1,
                passphrase : "12345678",
                groupName : "AAAZZZ456",
                goBand : wifiMg.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let p2pConnectResult = wifiMg.p2pConnect(wifiP2PConfig);
            console.info("[wifi_test]test p2pConnect successful." );
            let p2pCancelResult = wifiMg.p2pCancelConnect();
            await sleep(2000);
            console.info("[wifi_test]test p2pCancelConnect successful." );
            let removeGroupResult = wifiMg.removeGroup();
            console.info("[wifi_test]test removeGroup  successful " );
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0011
        * @tc.name testRemoveGroup
        * @tc.desc Test remove a nonexistent group.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0011', 0, async function (done) {
            let removeGroupResult = wifiMg.removeGroup(10000);
            await wifiMg.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number     SUB_Communication_WiFi_XTS_P2P_0002
        * @tc.name       testP2pLocalDevice
        * @tc.desc       Test get P2pLocalDevice API functionality.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('SUB_Communication_WiFi_XTS_P2P_0002', 0, async function (done) {
            await wifiMg.getP2pLocalDevice()
                .then(data => {
                    console.info("[wifi_test]getP2pLocalDevice  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName !=null);
                }).catch((error) => {
                    console.info("[wifi_test]getP2pLocalDevice promise error." + JSON.stringify(error));
                    expect().assertFail();
                });
            function getP2pLocal(){
                return new Promise((resolve, reject) => {
                    wifiMg.getP2pLocalDevice(
                        (err, ret) => {
                            if(err) {
                                console.info("[wifi_test]getP2pLocalDevice callback failed : " + JSON.stringify(err));
                                return;
                            }
                            console.info("[wifi_test]getP2pLocalDevice callback result: " + JSON.stringify(ret));
                            console.info("deviceName: " + ret.deviceName + "deviceAddress: " +
                            ret.deviceAddress + "primaryDeviceType: " + ret.primaryDeviceType +
                            "deviceStatus: " + ret.deviceStatus + "groupCapabilitys: " +
                            ret.groupCapabilitys );
                            resolve();
                        });
                });
            }
            await getP2pLocal();
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0010
        * @tc.name testGetP2pLinkedInfo
        * @tc.desc Test getP2pLinkedInfo API functionality
        * @tc.type Function
        * @tc.level Level 2
        */
        it('SUB_Communication_WiFi_XTS_P2P_0010', 0, async function(done) {
            let p2pConnectState = {
                DISCONNECTED :0,
                CONNECTED : 1,
            };
            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()
                });
            function getP2pLinkedInfoResult(){
                return new Promise((resolve, reject) => {
                    wifiMg.getP2pLinkedInfo(
                        (err, result) => {
                            if(err) {
                                console.info("[wifi_test]failed to getP2pLinkedInfo callback:" + JSON.stringify(err));
                                return;
                            }
                            let resultLength = Object.keys(result).length;
                            console.info("[wifi_test]getP2pLinkedInfo callback:" + JSON.stringify(resultLength));
                            console.info("connectState: " + result.connectState +
                            "isGroupOwner: " + result.isGroupOwner +
                            "groupOwnerAddr: " + result.groupOwnerAddr);
                            expect(true).assertEqual(resultLength!=0);
                            resolve();
                        });
                });
            }
            await getP2pLinkedInfoResult();
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0001
        * @tc.name testGetP2pPeerDevices
        * @tc.desc Test getP2pPeerDevices promise API functionality
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0001', 0, async function(done){
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let startDiscover = wifiMg.startDiscoverDevices();
            await sleep(2000);
            await wifiMg.getP2pPeerDevices()
                .then((data)  => {
                    let resultLength = Object.keys(data).length;
                    console.info("[wifi_test]getP2pPeerDevices  promise result -> " + JSON.stringify(data));
                    expect(true).assertEqual(resultLength >= 0);
                }).catch((error) => {
                    console.info("[wifi_test]getP2pPeerDevices promise then error." + JSON.stringify(error));
                    expect().assertFail();
                });
            let stopDiscover = wifiMg.stopDiscoverDevices();
            done();
        })
        /**
        * @tc.number SUB_Communication_WiFi_XTS_P2P_0101
        * @tc.name testGetP2pPeerDevices
        * @tc.desc Test getP2pPeerDevices callback API functionality
        * @tc.type Function
        * @tc.level Level 0
        */
        it('SUB_Communication_WiFi_XTS_P2P_0101', 0, async function(done){
            console.log("[wifi_test]check the state of wifi: " + wifiMg.isWifiActive());
            expect(wifiMg.isWifiActive()).assertTrue();
            let startDiscover = wifiMg.startDiscoverDevices();
            await sleep(2000);
            function getP2pPeerDevicesResult(){
                return new Promise((resolve, reject) => {
                    wifiMg.getP2pPeerDevices(
                        (err, result) => {
                            if(err) {
                                console.error('[wifi_test]failed to getP2pPeerDevices :' + JSON.stringify(err));
                            }
                            console.info("[wifi_test] getP2pPeerDevices callback result :" + JSON.stringify(result));
                            let len = Object.keys(result).length;
                            for (let j = 0; j < len; ++j) {
                                console.info("deviceName: " + result[j].deviceName +
                                "deviceAddress: " + result[j].deviceAddress +
                                "primaryDeviceType: " + result[j].primaryDeviceType +
                                "deviceStatus: " + result[j].deviceStatus +
                                "groupCapabilitys: " + result[j].groupCapabilitys );
                                if(result[j].deviceStatus == wifiMg.P2pDeviceStatus.UNAVAILABLE){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifiMg.P2pDeviceStatus.CONNECTED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifiMg.P2pDeviceStatus.INVITED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifiMg.P2pDeviceStatus.FAILED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifiMg.P2pDeviceStatus.AVAILABLE){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                            }
                            resolve();
                        });
                });
            }
            await getP2pPeerDevicesResult();
            done();
        });
        console.log("*************[wifi_test] start wifi js unit test end*************");
    })
 }
--- a/communication/wifi_p2p/src/main/js/test/WifiP2PEvent.test.js
+++ b/communication/wifi_p2p/src/main/js/test/WifiP2PEvent.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 wifi from '@ohos.wifi'
 function sleep(delay) {
    return new Promise(resovle => setTimeout(resovle, delay))
 }
 function checkWifiPowerOn(){
    console.info("[wifi_test]wifi status:" + wifi.isWifiActive());
 }
 export default function actsWifiEventTest() {
    describe('actsWifiEventTest', function () {
        beforeEach(function () {
            console.info("[wifi_test]beforeEach start" );
            checkWifiPowerOn();
        })
        afterEach(async function () {
            console.info("[wifi_test]afterEach start" );
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0008
        * @tc.name testp2pStateChange
        * @tc.desc Test p2pStateChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('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));
            }
            wifi.on(p2pState, p2pStateChangeCallback);
            await sleep(3000);
            wifi.off(p2pState, p2pStateChangeCallback);
            done();
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0009
        * @tc.name testp2pConnectionChange
        * @tc.desc Test p2pConnectionChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('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));
            }
            wifi.on(p2pConnectionState, p2pConnectionChangeCallback);
            let wifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -1,
                passphrase : "12345678",
                groupName : "AAAZZZ456",
                goBand : wifi.GroupOwnerBand.GO_BAND_AUTO
            };
            let connectResult = wifi.p2pConnect(wifiP2PConfig);
            console.info("[wifi_test]test p2pConnect result." + connectResult);
            await wifi.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);
            wifi.off(p2pConnectionState, p2pConnectionChangeCallback);
            let removeGroupResult = wifi.removeGroup();
            console.info("[wifi_test]test start removeGroup:" + removeGroupResult);
            expect(removeGroupResult).assertTrue();
            done();
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0012
        * @tc.name testp2pDeviceChange
        * @tc.desc Test p2pDeviceChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('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));
            }
            wifi.on(p2pDeviceState, p2pDeviceChangeCallback);
            await sleep(3000);
            wifi.off(p2pDeviceState, p2pDeviceChangeCallback);
            done();
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0010
        * @tc.name testp2pPeerDeviceChange
        * @tc.desc Test p2pPeerDeviceChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('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));
            }
            wifi.on(p2pPeerDeviceState, p2pPeerDeviceChangeCallback);
            let startDiscover = wifi.startDiscoverDevices();
            await sleep(3000);
            expect(startDiscover).assertTrue();
            let stopDiscover = wifi.stopDiscoverDevices();
            console.info("[wifi_test] test stopDiscoverDevices result." + stopDiscover);
            wifi.off(p2pPeerDeviceState, p2pPeerDeviceChangeCallback);
            done();
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0013
        * @tc.name testp2pPersistentGroupChange
        * @tc.desc Test p2pPersistentGroupChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_Event_Test_0013', 0, async function (done) {
            let p2pGroupState = "p2pPersistentGroupChange";
            let p2pPersistentGroupChangeCallback = () => {
                console.info("[wifi_test]p2pPersistentGroupChange callback, result: " + JSON.stringify(result));
            }
            wifi.on(p2pGroupState, p2pPersistentGroupChangeCallback);
            let WifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -2,
                passphrase : "12345678",
                groupName : "AAAZZZ123",
                goBand : wifi.GroupOwnerBand.GO_BAND_AUTO,
            };
            let createGroupResult = wifi.createGroup(WifiP2PConfig);
            await (2000);
            console.info("[wifi_test] test createGroup result." + createGroupResult)
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    let resultLength = Object.keys(data).length;
                    console.info("[wifi_test] getCurrentGroup  promise result -> " + JSON.stringify(data));
                    expect(true).assertEqual(resultLength!=0);
                });
            wifi.off(p2pGroupState, p2pPersistentGroupChangeCallback);
            done();
        })
        /**
        * @tc.number Communication_WiFi_Event_Test_0011
        * @tc.name testpp2pDiscoveryChange
        * @tc.desc Test p2pDiscoveryChange callback
        * @tc.type Function
        * @tc.level Level 3
        */
        it('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));
            }
            wifi.on(p2pPeerDeviceState, p2pDiscoveryChangeCallback);
            let startDiscover = wifi.startDiscoverDevices();
            await sleep(3000);
            expect(startDiscover).assertTrue();
            let stopDiscover = wifi.stopDiscoverDevices();
            console.info("[wifi_test] test stopDiscoverDevices result." + stopDiscover);
            wifi.off(p2pPeerDeviceState, p2pDiscoveryChangeCallback);
            done();
        })
        console.log("*************[wifi_test] start wifi js unit test end*************");
    })
 }
--- a/communication/wifi_p2p/src/main/js/test/WifiP2PFunction.test.js
+++ b/communication/wifi_p2p/src/main/js/test/WifiP2PFunction.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 wifi from '@ohos.wifi'
 function sleep(delay) {
    return new Promise(resovle => setTimeout(resovle, delay))
 }
 function checkWifiPowerOn(){
    console.info("[wifi_test]/wifi status:" + wifi.isWifiActive());
 }
 export default function actsWifiFunctionTest() {
    describe('actsWifiFunctionTest', function () {
        beforeEach(function () {
            console.info("[wifi_test]beforeEach start" );
            checkWifiPowerOn();
        })
        afterEach(async function () {
            console.info("[wifi_test]afterEach start" );
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0003
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup and getCurrentGroup API Function
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0003', 0, async function(done) {
            let wifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -1,
                passphrase : "12345678",
                groupName : "AAAZZZ123",
                goBand : wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            console.log("[wifi_test]createGroup result: " + JSON.stringify(createGroupResult));
            await sleep(2000);
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup promise result -> " + JSON.stringify(data));
                    expect(true).assertEqual(data.groupName == wifiP2PConfig.groupName);
                });
            function getCurrentGroupResult(){
                return new Promise((resolve, reject) => {
                    wifi.getCurrentGroup(
                        (err, result) => {
                            if(err) {
                                console.info("[wifi_test]failed to get getCurrentGroup:" + JSON.stringify(err));
                                expect().assertFail();
                            }
                            console.info("[wifi_test]getCurrentGroup callback:" + JSON.stringify(result));
                            console.info("isP2pGo: " + result.isP2pGo +
                            "deviceName: " + result.ownerInfo.deviceName +
                            "deviceAddress: " + result.ownerInfo.deviceAddress +
                            "primaryDeviceType: " + result.ownerInfo.primaryDeviceType +
                            "deviceStatus: " + result.ownerInfo.deviceStatus +
                            "groupCapabilitys: " + result.ownerInfo.groupCapabilitys +
                            "passphrase: " + result.passphrase + "interface: "+ result.interface
                            + "groupName: " + result.groupName +
                            "frequency: " + result.frequency + "goIpAddress: " + result.goIpAddress);
                            console.info("[wifi_test] clientDevices:" + JSON.stringify(result.clientDevices));
                            console.info("[wifi_test] ownerInfo:" + JSON.stringify(result.WifiP2pDevice));
                            resolve();
                        });
                });
            }
            await getCurrentGroupResult();
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0004
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Setting a 7-bit Key Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0004', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "1234567",
                groupName: "test_pass",
                goBand: wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            console.info("[wifi_test]test createGroup end." + JSON.stringify(createGroupResult));
            await sleep(2000);
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.networkId == -999);
                });
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0104
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting: Chinese, English, and characters Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0104', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "123@%abcD",
                groupName: "test_pass1",
                goBand: wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            console.info("[wifi_test]test createGroup end." + JSON.stringify(createGroupResult));
            await sleep(2000);
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result : " + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase == wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0204
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting 64 bit Function.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0204', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "abc345678901234567890123456789012345678901234567890123456789012",
                groupName: "test_pass2",
                goBand: wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            console.info("[wifi_test]test createGroup end." + JSON.stringify(createGroupResult));
            await sleep(2000);
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup promise result : " + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase == wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0304
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Key setting 65 bitsFunction.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0304', 0, async function (done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress: "00:00:00:00:00:00",
                netId: -1,
                passphrase: "abc3456789012345678901234567890123456789012345678901234567890123",
                groupName: "test_pass3",
                goBand: wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            console.info("[wifi_test]test createGroup end." + JSON.stringify(createGroupResult));
            await sleep(2000);
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(data.passphrase != wifiP2PConfig.passphrase);
                });
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0007
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-2.4 GHz frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('Communication_WiFi_XTS_P2P_0007', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let wifiP2PConfig = {
                deviceAddress : "00:00:00:00:00:00",
                netId : -1,
                passphrase : "12345678",
                groupName : "test_band1",
                goBand : wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let createGroupResult = wifi.createGroup(wifiP2PConfig);
            await sleep(2000);
            console.info("[wifi_test] test createGroup result." + createGroupResult)
            expect(createGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test]getCurrentGroup  promise result :" + JSON.stringify(data));
                    expect(true).assertEqual(2412 < data.frequency < 2484 );
                });
            let removeGroupResult = wifi.removeGroup();
            await sleep(2000);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0107
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-5 GHz frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('Communication_WiFi_XTS_P2P_0107', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress : "00:00:00:00:00:00",
                    netId : -1,
                    passphrase : "12345678",
                    groupName : "test_band2",
                    goBand : wifi.GroupOwnerBand.GO_BAND_5GHZ,
                };
                let createGroupResult = wifi.createGroup(wifiP2PConfig);
                await sleep(2000);
                console.info("[wifi_test]test createGroup result." + createGroupResult)
                expect(createGroupResult).assertTrue();
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result :" + JSON.stringify(data));
                        expect(true).assertEqual(5160 < data.frequency < 5865);
                    });
                let removeGroupResult = await wifi.removeGroup();
                await sleep(2000);
                expect(removeGroupResult).assertTrue();
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup 5G goBand result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0207
        * @tc.name testCreateGroup
        * @tc.desc Test createGroup-Auto frequency band setting Function
        * @tc.type Function
        * @tc.level Level 0
        */
        it('Communication_WiFi_XTS_P2P_0207', 0, async function(done) {
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            try {
                let wifiP2PConfig = {
                    deviceAddress : "00:00:00:00:00:00",
                    netId : -1,
                    passphrase : "12345678",
                    groupName : "test_band3",
                    goBand : wifi.GroupOwnerBand.GO_BAND_AUTO,
                };
                let createGroupResult = wifi.createGroup(wifiP2PConfig);
                await sleep(2000);
                console.info("[wifi_test]test createGroup result." + createGroupResult)
                expect(createGroupResult).assertTrue();
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test]getCurrentGroup promise result : " + JSON.stringify(data));
                        expect(true).assertEqual(data.frequency != null );
                    });
                let removeGroupResult = await wifi.removeGroup();
                await sleep(2000);
                expect(removeGroupResult).assertTrue();
                await wifi.getCurrentGroup()
                    .then(data => {
                        console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                        expect(true).assertEqual(data.deviceName == null);
                    });
            }catch(error){
                console.info("[wifi_test]createGroup auto  goBand result : " + JSON.stringify(error.message));
                expect(true).assertEqual( (JSON.stringify(error.message)) !=null);
            }
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0009
        * @tc.name testP2pCancelConnect
        * @tc.desc Test p2pCancelConnect Group API functionality.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0009', 0, async function (done) {
            let wifiP2PConfig = {
                deviceAddress : "11:22:33:44:55:66",
                netId : -1,
                passphrase : "12345678",
                groupName : "AAAZZZ456",
                goBand : wifi.GroupOwnerBand.GO_BAND_2GHZ,
            };
            let p2pConnectResult = wifi.p2pConnect(wifiP2PConfig);
            console.info("[wifi_test]test p2pConnect result." + p2pConnectResult);
            let p2pCancelResult = wifi.p2pCancelConnect();
            await sleep(2000);
            console.info("[wifi_test]test p2pCancelConnect result." + p2pCancelResult);
            expect(p2pCancelResult).assertTrue();
            let removeGroupResult = wifi.removeGroup();
            console.info("[wifi_test]test start removeGroup:" + removeGroupResult);
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0011
        * @tc.name testRemoveGroup
        * @tc.desc Test remove a nonexistent group.
        * @tc.type Function
        * @tc.level Level 3
        */
        it('Communication_WiFi_XTS_P2P_0011', 0, async function (done) {
            let removeGroupResult = wifi.removeGroup(10000);
            console.info("[wifi_test]removeGroup(10000) result : " + JSON.stringify(removeGroupResult));
            expect(removeGroupResult).assertTrue();
            await wifi.getCurrentGroup()
                .then(data => {
                    console.info("[wifi_test] getCurrentGroup  promise result1 :" + JSON.stringify(data));
                    expect(true).assertEqual(data.deviceName == null);
                });
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0010
        * @tc.name testGetP2pLinkedInfo
        * @tc.desc Test getP2pLinkedInfo API functionality
        * @tc.type Function
        * @tc.level Level 2
        */
        it('Communication_WiFi_XTS_P2P_0010', 0, async function(done) {
            let P2pConnectState = {
                DISCONNECTED :0,
                CONNECTED : 1,
            };
            await wifi.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()
                });
            function getP2pLinkedInfoResult(){
                return new Promise((resolve, reject) => {
                    wifi.getP2pLinkedInfo(
                        (err, result) => {
                            if(err) {
                                console.info("[wifi_test]failed to getP2pLinkedInfo callback:" + JSON.stringify(err));
                                return;
                            }
                            let resultLength = Object.keys(result).length;
                            console.info("[wifi_test]getP2pLinkedInfo callback:" + JSON.stringify(resultLength));
                            console.info("connectState: " + result.connectState +
                            "isGroupOwner: " + result.isGroupOwner +
                            "groupOwnerAddr: " + result.groupOwnerAddr);
                            expect(true).assertEqual(resultLength!=0);
                            resolve();
                        });
                });
            }
            await getP2pLinkedInfoResult();
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0001
        * @tc.name testGetP2pPeerDevices
        * @tc.desc Test getP2pPeerDevices promise API functionality
        * @tc.type Function
        * @tc.level Level 0
        */
        it('Communication_WiFi_XTS_P2P_0001', 0, async function(done){
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let startDiscover = wifi.startDiscoverDevices();
            await sleep(2000);
            expect(startDiscover).assertTrue();
            await wifi.getP2pPeerDevices()
                .then((data)  => {
                    let resultLength = Object.keys(data).length;
                    console.info("[wifi_test]getP2pPeerDevices  promise result -> " + JSON.stringify(data));
                    expect(true).assertEqual(resultLength >= 0);
                }).catch((error) => {
                    console.info("[wifi_test]getP2pPeerDevices promise then error." + JSON.stringify(error));
                    expect().assertFail();
                });
            let stopDiscover = wifi.stopDiscoverDevices();
            console.info("[wifi_test]test stopDiscoverDevices result." + stopDiscover);
            done();
        })
        /**
        * @tc.number Communication_WiFi_XTS_P2P_0101
        * @tc.name testGetP2pPeerDevices
        * @tc.desc Test getP2pPeerDevices callback API functionality
        * @tc.type Function
        * @tc.level Level 0
        */
        it('Communication_WiFi_XTS_P2P_0101', 0, async function(done){
            console.log("[wifi_test]check the state of wifi: " + wifi.isWifiActive());
            expect(wifi.isWifiActive()).assertTrue();
            let startDiscover = wifi.startDiscoverDevices();
            await sleep(2000);
            expect(startDiscover).assertTrue();
            function getP2pPeerDevicesResult(){
                return new Promise((resolve, reject) => {
                    wifi.getP2pPeerDevices(
                        (err, result) => {
                            if(err) {
                                console.error('[wifi_test]failed to getP2pPeerDevices :' + JSON.stringify(err));
                            }
                            console.info("[wifi_test] getP2pPeerDevices callback result :" + JSON.stringify(result));
                            let len = Object.keys(result).length;
                            for (let j = 0; j < len; ++j) {
                                console.info("deviceName: " + result[j].deviceName +
                                "deviceAddress: " + result[j].deviceAddress +
                                "primaryDeviceType: " + result[j].primaryDeviceType +
                                "deviceStatus: " + result[j].deviceStatus +
                                "groupCapabilitys: " + result[j].groupCapabilitys );
                                if(result[j].deviceStatus == wifi.P2pDeviceStatus.UNAVAILABLE){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifi.P2pDeviceStatus.CONNECTED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifi.P2pDeviceStatus.INVITED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifi.P2pDeviceStatus.FAILED){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                                if(result[j].deviceStatus == wifi.P2pDeviceStatus.AVAILABLE){
                                    console.info("deviceStatus: " + result[j].deviceStatus);
                                }
                            }
                            resolve();
                        });
                });
            }
            await getP2pPeerDevicesResult();
            done();
        });
        console.log("*************[wifi_test] start wifi js unit test end*************");
    })
 }
--- a/communication/wifi_standard/src/main/js/test/WifiManagerStationFunctions.test.js
+++ b/communication/wifi_standard/src/main/js/test/WifiManagerStationFunctions.test.js
@@ -246,28 +246,28 @@ export default function actsWifiManagerFunctionsTest() {
                            "suppState: " + result.suppState + "connState: " + result.connState
                            + "macType: " + result.macType);
                            let state = wifiMg.getLinkedInfo().ConnState;
-                            if (state == wifiMg.connState.SCANNING) {
+                            if (state == wifiMg.ConnState.SCANNING) {
                                expect(true).assertEqual(state == 0);
                            }
-                            if (state == wifiMg.connState.CONNECTING) {
+                            if (state == wifiMg.ConnState.CONNECTING) {
                                expect(true).assertEqual(state == 1);
                            }
-                            if (state == wifiMg.connState.AUTHENTICATING) {
+                            if (state == wifiMg.ConnState.AUTHENTICATING) {
                                expect(true).assertEqual(state == 2);
                            }
-                            if (state == wifiMg.connState.OBTAINING_IPADDR) {
+                            if (state == wifiMg.ConnState.OBTAINING_IPADDR) {
                                expect(true).assertEqual(state == 3);
                            }
-                            if (state == wifiMg.connState.CONNECTED) {
+                            if (state == wifiMg.ConnState.CONNECTED) {
                                expect(true).assertEqual(state == 4);
                            }
-                            if (state == wifiMg.connState.DISCONNECTING) {
+                            if (state == wifiMg.ConnState.DISCONNECTING) {
                                expect(true).assertEqual(state == 5);
                            }
-                            if (state == wifiMg.connState.DISCONNECTED) {
+                            if (state == wifiMg.ConnState.DISCONNECTED) {
                                expect(true).assertEqual(state == 6);
                            }
-                            if (state == wifiMg.connState.UNKNOWN) {
+                            if (state == wifiMg.ConnState.UNKNOWN) {
                                expect(true).assertEqual(state == 7);
                            }
                            resolve();