!4068 update intrerrupt xts test

Merge pull request !4068 from zhujie/master

multimedia/audio/audio_js_standard/audioManager/src/main/js/test/AudioFramework.test.js

@@ -4285,5 +4285,137 @@ describe('audioManger', function () {
         done();
     })
 
+    /*
+                * @tc.name:RequestIndependentInterrupt_001
+                * @tc.desc: requestIndependentInterrupt callback
+                * @tc.type: FUNC
+                * @tc.require: Issue Number
+    */
+    it("RequestIndependentInterrupt_001", 0, function (done) {
+        audioManager.requestIndependentInterrupt(audio.FocusType.FOCUS_TYPE_RECORDING ,(err,data)=>{
+            if(err){
+                expect(true).assertEqual(false);
+                return done();
+            }
+            expect(data).assertEqual(true);
+            done();
+        })
+    })
+
+    /*
+                * @tc.name:RequestIndependentInterrupt_002
+                * @tc.desc: requestIndependentInterrupt promise
+                * @tc.type: FUNC
+                * @tc.require: Issue Number
+    */
+    it("RequestIndependentInterrupt_002", 0, function (done) {
+        audioManager.requestIndependentInterrupt(audio.FocusType.FOCUS_TYPE_RECORDING).then(data=>{
+            expect(data).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(true).assertEqual(false);
+            done();
+        })
+    })
+
+    /*
+                * @tc.name:RequestIndependentInterrupt_003
+                * @tc.desc: requestIndependentInterrupt ,set param as '0',will catch error with type error
+                * @tc.type: FUNC
+                * @tc.require: Issue Number
+    */
+    it("RequestIndependentInterrupt_003", 0,async function (done) {
+        let focusType = '0';
+        try{
+            await audioManager.requestIndependentInterrupt(focusType)
+        }catch(err){
+            expect('assertion (false) failed: type mismatch').assertEqual(err.message);
+        }
+        done();
+    })
+
+    /*
+                * @tc.name:RequestIndependentInterrupt_004
+                * @tc.desc: requestIndependentInterrupt ,set param as 99,will catch error  out of border
+                * @tc.type: FUNC
+                * @tc.require: Issue Number
+    */
+    it("RequestIndependentInterrupt_004", 0, function (done) {
+        let focusType = 99;
+        audioManager.requestIndependentInterrupt(focusType).then(data=>{
+            expect(data).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(err).assertEqual(undefined);
+            done();
+        });
+    })
+
+    /*
+                * @tc.name:AbandonIndependentInterrupt_001
+                * @tc.desc: abandonIndependentInterrupt callback
+                * @tc.type: FUNC
+                * @tc.require: Issue Number
+    */
+    it("AbandonIndependentInterrupt_001", 0, function (done) {
+        audioManager.abandonIndependentInterrupt(audio.FocusType.FOCUS_TYPE_RECORDING,(err,data)=>{
+            if(err){
+                expect(true).assertEqual(false);
+                return done();
+            }
+            expect(data).assertEqual(true);
+            done();
+        })
+    })
+
+    /*
+    * @tc.name:AbandonIndependentInterrupt_002
+    * @tc.desc: abandonIndependentInterrupt promise
+    * @tc.type: FUNC
+    * @tc.require: Issue Number
+    */
+    it("AbandonIndependentInterrupt_002", 0, function (done) {
+        audioManager.abandonIndependentInterrupt(audio.FocusType.FOCUS_TYPE_RECORDING).then(data=>{
+            expect(data).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(true).assertEqual(false);
+            done();
+        })
+    })
+
+    /*
+   * @tc.name:AbandonIndependentInterrupt_003
+   * @tc.desc: abandonIndependentInterrupt ,set param as '0',will catch error with type error
+   * @tc.type: FUNC
+   * @tc.require: Issue Number
+   */
+    it("AbandonIndependentInterrupt_003", 0, function (done) {
+        let focusType='0';
+        try{
+            audioManager.abandonIndependentInterrupt(focusType).then(data=>{
+                expect(false).assertTrue();
+            });
+        }catch(err){
+            expect('assertion (false) failed: type mismatch').assertEqual(err.message);
+        }
+        done();
+    })
 
+    /*
+    * @tc.name:AbandonIndependentInterrupt_004
+    * @tc.desc: abandonIndependentInterrupt ,set param as 99,will catch error  out of border
+    * @tc.type: FUNC
+    * @tc.require: Issue Number
+    */
+    it("AbandonIndependentInterrupt_004", 0, function (done) {
+        let focusType = 99;
+        audioManager.abandonIndependentInterrupt(focusType).then(data=>{
+            expect(data).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(err).assertEqual(undefined);
+            done();
+        })
+    })
 })
\ No newline at end of file

multimedia/audio/audio_js_standard/audioManager/src/main/js/test/AudioRenderer.test.js

@@ -7523,4 +7523,205 @@ describe('audioRenderer', function () {
         done();
     })
 
+    /*
+     * @tc.name:SetInterruptMode_001
+     * @tc.desc:SetInterruptMode mode 0 callback,is public share mode
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SetInterruptMode_001", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = 0;
+        audioRenderer.setInterruptMode(mode,(err,data)=>{
+            if(err){
+                expect(true).assertEqual(false);
+                return done();
+            }
+            expect(true).assertEqual(true);
+            done();
+        })
+    })
+
+    /*
+     * @tc.name:SetInterruptMode_002
+     * @tc.desc:SetInterruptMode mode 1 callback,is independent mode
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SetInterruptMode_002", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = 1;
+        audioRenderer.setInterruptMode(mode,(err,data)=>{
+            if(err){
+                expect(true).assertEqual(false);
+                return done();
+            }
+            expect(true).assertEqual(true);
+            done();
+        })
+    })
+
+    /*
+     * @tc.name:SetInterruptMode_003
+     * @tc.desc:SetInterruptMode mode 0 promise,is public share mode
+     * @tc.type: FUNC
+     * @tc.require: Issue Number
+     */
+    it("SetInterruptMode_003", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = 0;
+        audioRenderer.setInterruptMode(mode).then(data=>{
+            expect(true).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(true).assertEqual(false);
+            done();
+        })
+    })
+
+    /*
+        * @tc.name:SetInterruptMode_004
+        * @tc.desc:SetInterruptMode mode 1 promise,is independent mode
+        * @tc.type: FUNC
+        * @tc.require: Issue Number
+        */
+    it("SetInterruptMode_004", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = 1;
+        audioRenderer.setInterruptMode(mode).then(data=>{
+            expect(true).assertEqual(true);
+            done();
+        }).catch(err=>{
+            expect(true).assertEqual(false);
+            done();
+        })
+    })
+
+    /*
+    * @tc.name:SetInterruptMode_005
+    * @tc.desc:SetInterruptMode mode '1',will catch error with type error
+    * @tc.type: FUNC
+    * @tc.require: Issue Number
+    */
+    it("SetInterruptMode_005", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = '1';
+        try{
+            let data = await audioRenderer.setInterruptMode(mode);
+            expect(false).assertEqual(false);
+            done();
+        }catch(err){
+            expect('assertion (false) failed: type mismatch').assertEqual(err.message);
+            done();
+        }
+    })
+
+    /*
+   * @tc.name:SetInterruptMode_006
+   * @tc.desc:SetInterruptMode mode 2,will catch error with out of border
+   * @tc.type: FUNC
+   * @tc.require: Issue Number
+   */
+    it("SetInterruptMode_006", 0,async function (done) {
+        var audioStreamInfo = {
+            samplingRate: audio.AudioSamplingRate.SAMPLE_RATE_48000,
+            channels: audio.AudioChannel.CHANNEL_1,
+            sampleFormat: audio.AudioSampleFormat.SAMPLE_FORMAT_S16LE,
+            encodingType: audio.AudioEncodingType.ENCODING_TYPE_RAW
+        }
+        var audioRendererInfo = {
+            content: audio.ContentType.CONTENT_TYPE_MUSIC,
+            usage: audio.StreamUsage.STREAM_USAGE_MEDIA,
+            rendererFlags: 0
+        }
+        var audioRendererOptions = {
+            streamInfo: audioStreamInfo,
+            rendererInfo: audioRendererInfo
+        }
+        let audioRenderer = await audio.createAudioRenderer(audioRendererOptions);
+        let mode = 2;
+        try{
+            let data = await audioRenderer.setInterruptMode(mode)
+            expect(true).assertEqual(true);
+            done();
+        }catch(err){
+            expect(err).assertEqual(undefined);
+            done();
+        }
+    })
 })
\ No newline at end of file