diff --git a/multimedia/BUILD.gn b/multimedia/BUILD.gn index 669f594f682cdb27ffbc2fc47944f8f64244e578..18e245481818e218b337b02956be91021ec5b529 100644 --- a/multimedia/BUILD.gn +++ b/multimedia/BUILD.gn @@ -19,7 +19,8 @@ group("multimedia") { deps = [ "audio/audio_js_standard/audioPlayer:audio_player_js_hap" , "audio/audio_js_standard/audioPlayer_API:audio_player_api_js_hap", - "media/media_cpp_test_standard:ActsMediaCppStandardTest", + "audio/audio_js_standard/audioManager:audio_manager_js_hap", + "media/media_cpp_test_standard:ActsMediaCppStandardTest" ] } else { deps = [ diff --git a/multimedia/audio/audio_js_standard/audioManager/BUILD.gn b/multimedia/audio/audio_js_standard/audioManager/BUILD.gn index 63dce971b40d49a2fc33aaf5204f09dc13e6e5a6..436023587f99460aa3f26364e8a0a74a89434cf5 100755 --- a/multimedia/audio/audio_js_standard/audioManager/BUILD.gn +++ b/multimedia/audio/audio_js_standard/audioManager/BUILD.gn @@ -12,7 +12,7 @@ # limitations under the License. import("//test/xts/tools/build/suite.gni") -ohos_js_hap_suite("audio_manager_js_test") { +ohos_js_hap_suite("audio_manager_js_hap") { test_hap_name = "AudioManagerJsTest" - hap_source_path = "hap/entry-debug-rich-signed.hap" + hap_source_path = "hap/AudioManager.hap" } diff --git a/multimedia/audio/audio_js_standard/audioManager/hap/AudioManager.hap b/multimedia/audio/audio_js_standard/audioManager/hap/AudioManager.hap new file mode 100644 index 0000000000000000000000000000000000000000..54ce271949b3b900f4689a602e95278b0c590a24 Binary files /dev/null and b/multimedia/audio/audio_js_standard/audioManager/hap/AudioManager.hap differ diff --git a/multimedia/audio/audio_js_standard/audioManager/hap/entry-debug-rich-signed.hap b/multimedia/audio/audio_js_standard/audioManager/hap/entry-debug-rich-signed.hap deleted file mode 100755 index 9f875f974f29fc7ad6da92d74e451a1dd7c33eb3..0000000000000000000000000000000000000000 Binary files a/multimedia/audio/audio_js_standard/audioManager/hap/entry-debug-rich-signed.hap and /dev/null differ diff --git a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioFramework.test.js b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioFramework.test.js new file mode 100644 index 0000000000000000000000000000000000000000..a179536b7b5cd483138d70d399d4f551d52dde95 --- /dev/null +++ b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioFramework.test.js @@ -0,0 +1,4746 @@ +/* + * Copyright (C) 2021 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 audio from '@ohos.multimedia.audio'; + +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'; + +describe('AudioFramework.test.js', async function () { + console.info('AudioFrameworkTest: Create AudioManger Object JS Framework'); + + const audioManager = audio.getAudioManager(); + var deviceRoleValue = null; + var deviceTypeValue = null; + var volErrorMesg = 'Error, Operation not supported or Failed'; + var audioMedia = 3; + var audioRingtone = 2; + var minVol = 0; + var maxVol = 15; + var lowVol = 5; + var highVol = 14; + var outOfRangeVol = 28; + + beforeAll(function () { + console.info('AudioFrameworkTest: beforeAll： Prerequisites at the test suite level, which are executed before the test suite is executed.'); + + }) + + beforeEach(function () { + console.info('AudioFrameworkTest: beforeEach：Prerequisites at the test case level, which are executed before each test case is executed.'); + + }) + afterEach(function () { + console.info('AudioFrameworkTest: afterEach： Test case-level clearance conditions, which are executed after each test case is executed.'); + + }) + afterAll(function () { + console.info('AudioFrameworkTest: afterAll： Test suite-level cleanup condition, which is executed after the test suite is executed'); + + }) + + + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_001 + * @tc.name : setVolume - Media - Promise + * @tc.desc : Setvol to 1 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_001', 0, async function (done) { + const promise = audioManager.setVolume(audioMedia,lowVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Media setVolume promise: successful'); + audioManager.getVolume(audioMedia).then(async function (data) { + if(data == lowVol){ + console.info('AudioFrameworkTest: Media getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_002 + * @tc.name : setVolume - Media - Promise - MAX Volume + * @tc.desc : Setvol to 15 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_002', 0, async function (done) { + + const promise = audioManager.setVolume(audioMedia,maxVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Media setVolume promise: successful'); + + audioManager.getVolume(audioMedia).then(async function (data) { + if(data == maxVol){ + console.info('AudioFrameworkTest: Media getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + + }); + }); + await promise; + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_003 + * @tc.name : setVolume - Media - Promise - Mute Volume + * @tc.desc : Setvol to 0 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_003', 0, async function (done) { + + const promise = audioManager.setVolume(audioMedia,minVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Media setVolume promise: successful'); + + audioManager.getVolume(audioMedia).then(async function (data) { + if(data == minVol){ + console.info('AudioFrameworkTest: Media getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + + }); + }); + await promise; + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_004 + * @tc.name : setVolume - Media - Promise - Out of range Volume + * @tc.desc : Setvol to 28 (More than 15) + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_004', 0, async function (done) { + console.info('AudioFrameworkTest: Media setVolume Promise:Out of range: Setvol 100'); + await audioManager.setVolume(audioMedia,outOfRangeVol).then((data) => { + console.info('AudioFrameworkTest: Media setVolume Promise:Out of range: FAIL :' + data); + expect(false).assertTrue(); + }).catch((err) => { + console.info('AudioFrameworkTest: Media setVolume Promise:Out of range: PASS :' + err.message); + expect(volErrorMesg).assertEqual(err.message); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_005 + * @tc.name : setVolume - Media - Callback + * @tc.desc : Setvol to 14 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_005', 0, async function (done) { + + audioManager.setVolume(audioMedia,highVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Media setVolume successful `); + audioManager.getVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == highVol){ + console.info('AudioFrameworkTest: callback : Media getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_006 + * @tc.name : setVolume - Media - Callback - MAX Volume + * @tc.desc : Setvol to 15 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_006', 0, async function (done) { + + audioManager.setVolume(audioMedia,maxVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Media setVolume successful `); + audioManager.getVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == maxVol){ + console.info('AudioFrameworkTest: callback : Media getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_007 + * @tc.name : setVolume - Media - Callback - Mute Volume + * @tc.desc : Setvol to 0 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_007', 0, async function (done) { + + audioManager.setVolume(audioMedia,minVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Media setVolume successful `); + audioManager.getVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == minVol){ + console.info('AudioFrameworkTest: callback : Media getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_008 + * @tc.name : setVolume - Media - Callback - Out of range Volume + * @tc.desc : Setvol to 20 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_008', 0, async function (done) { + + audioManager.setVolume(audioMedia,outOfRangeVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: setVolume: Out of range: Callback: PASS: ${err.message}`); + expect(volErrorMesg).assertEqual(err.message); + } + else{ + console.info('AudioFrameworkTest: setVolume: callback : Media Out of range: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_009 + * @tc.name : setVolume - Ringtone - Promise + * @tc.desc : Setvol to 5 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_009', 0, async function (done) { + const promise = audioManager.setVolume(audioRingtone,lowVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: successful'); + audioManager.getVolume(audioRingtone).then(async function (data) { + if(data == lowVol){ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_010 + * @tc.name : setVolume - Ringtone - Promise - MAX Volume + * @tc.desc : Setvol to 15 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_010', 0, async function (done) { + + const promise = audioManager.setVolume(audioRingtone,maxVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: successful'); + audioManager.getVolume(audioRingtone).then(async function (data) { + if(data == maxVol){ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_011 + * @tc.name : setVolume - Ringtone - Promise - Mute Volume + * @tc.desc : Setvol to 0 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_011', 0, async function (done) { + + const promise = audioManager.setVolume(audioRingtone,minVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: successful'); + audioManager.getVolume(audioRingtone).then(async function (data) { + if(data == minVol){ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_012 + * @tc.name : setVolume - Ringtone - Promise - Out of range Volume + * @tc.desc : Setvol to 30 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_012', 0, async function (done) { + console.info('AudioFrameworkTest: Ringtone setVolume Promise: Out of range: Setvol 30'); + await audioManager.setVolume(audioRingtone,outOfRangeVol).then((data) => { + console.info('AudioFrameworkTest: Ringtone setVolume Promise:Out of range: FAIL :' + data); + expect(false).assertTrue(); + }).catch((err) => { + console.info('AudioFrameworkTest: Ringtone setVolume Promise:Out of range: PASS :' + (err.message)); + expect(volErrorMesg).assertEqual(err.message); + }); + done(); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_013 + * @tc.name : setVolume - Ringtone - Callback + * @tc.desc : Setvol to 7 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_013', 0, async function (done) { + + audioManager.setVolume(audioRingtone,highVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Ringtone setVolume successful `); + audioManager.getVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == highVol){ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_014 + * @tc.name : setVolume - Ringtone - Callback - MAX Volume + * @tc.desc : Setvol to 15 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_014', 0, async function (done) { + + audioManager.setVolume(audioRingtone,maxVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Ringtone setVolume successful `); + audioManager.getVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == maxVol){ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_015 + * @tc.name : setVolume - Ringtone - Callback - Mute Volume + * @tc.desc : Setvol to 0 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_015', 0, async function (done) { + + audioManager.setVolume(audioRingtone,minVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : Ringtone setVolume successful `); + audioManager.getVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == minVol){ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_016 + * @tc.name : setVolume - Ringtone - Callback - Out of range Volume + * @tc.desc : Setvol to 28 (more than max volume 15) + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_016', 0, async function (done) { + + audioManager.setVolume(audioRingtone,outOfRangeVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Out of range Volume: Callback: ${err.message}`); + expect(volErrorMesg).assertEqual(err.message); + } + else{ + console.info('AudioFrameworkTest: Out of range Volume: callback : Ringtone set volume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_017 + * @tc.name : setVolume - Media - Promise - Negative Value + * @tc.desc : Setvol to -1 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_017', 0, async function (done) { + console.info('AudioFrameworkTest: Media setVolume promise: Negative Value -1'); + await audioManager.setVolume(audioMedia,-1).then((data) => { //Setting negative audio volume for error senario + console.info('AudioFrameworkTest: Media setVolume Promise:Negetive: FAIL :' + data); + expect(false).assertTrue(); + }).catch((err) => { + console.info('AudioFrameworkTest: Media setVolume Promise:Negetive: PASS :' + (err.message)); + expect(true).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_018 + * @tc.name : setVolume - Media - Callback - Negative Value + * @tc.desc : Setvol to -1 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_018', 0, async function (done) { + + audioManager.setVolume(audioMedia,-1, (err, value) => { //Setting negative audio volume for error senario + if (err) { + console.error(`AudioFrameworkTest: setVolume Callback: Negative: PASS: ${err.message}`); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: setVolume callback : Media Negative: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_019 + * @tc.name : setVolume - Ringtone - Promise - Negative Value + * @tc.desc : Setvol to -1 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_019', 0, async function (done) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: Negative'); + await audioManager.setVolume(audioRingtone,-1).then((data) => { //Setting negative audio volume for error senario + console.info('AudioFrameworkTest: Ringtone setVolume Promise:Negative: FAIL :' + data); + expect(false).assertTrue(); + }).catch((err) => { + console.info('AudioFrameworkTest: Ringtone setVolume Promise:Negative: PASS :' + (err.message)); + expect(volErrorMesg).assertEqual(err.message); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_020 + * @tc.name : setVolume - Ringtone - Callback - Negative Value + * @tc.desc : Setvol to -1 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_020', 0, async function (done) { + + audioManager.setVolume(audioRingtone,-1, (err, value) => { //Setting negative audio volume for error senario + if (err) { + console.error(`AudioFrameworkTest: setVolume: Negative: Callback: ${err.message}`); + expect(volErrorMesg).assertEqual(err.message); + } + else{ + console.info('AudioFrameworkTest: setVolume: Negative: callback : Ringtone set volume: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_021 + * @tc.name : setVolume - Media - Promise - ENAME + * @tc.desc : Setvol to 5 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_021', 0, async function (done) { + + const promise = audioManager.setVolume(audio.AudioVolumeType.MEDIA,lowVol); + promise.then(async function (data) { + audioManager.getVolume(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data == lowVol){ + console.info('AudioFrameworkTest: Media getVolume Promise: ENAME : PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getVolume Promise: ENAME : FAIL :' + data); + expect(false).assertTrue(); + } + + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_022 + * @tc.name : setVolume - Media - Callback - ENAME + * @tc.desc : Setvol to 14 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_022', 0, async function (done) { + + audioManager.setVolume(audio.AudioVolumeType.MEDIA,highVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ENAME : ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : ENAME : Media setVolume successful `); + audioManager.getVolume(audio.AudioVolumeType.MEDIA, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media: ENAME : failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == highVol){ + console.info('AudioFrameworkTest: callback : Media getVolume: ENAME : PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media getVolume: ENAME : FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_023 + * @tc.name : setVolume - Ringtone - Promise - ENAME + * @tc.desc : Setvol to 14 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_023', 0, async function (done) { + + const promise = audioManager.setVolume(audio.AudioVolumeType.RINGTONE,highVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: ENAME: successful'); + + audioManager.getVolume(audio.AudioVolumeType.RINGTONE).then(async function (data) { + if(data == highVol){ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: ENAME: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: ENAME: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_024 + * @tc.name : setVolume - Ringtone - Callback - ENAME + * @tc.desc : Setvol to 5 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_024', 0, async function (done) { + audioManager.setVolume(audio.AudioVolumeType.RINGTONE,lowVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ENAME: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : ENAME: Ringtone setVolume successful `); + audioManager.getVolume(audio.AudioVolumeType.RINGTONE, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone: ENAME: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == lowVol){ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: ENAME: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: ENAME: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_025 + * @tc.name : setVolume - Media - Promise - Change Ringtone vol + * @tc.desc : Setvol to 5 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_025', 0, async function (done) { + + const promise = audioManager.setVolume(audio.AudioVolumeType.MEDIA,lowVol); + promise.then(async function (data) { + audioManager.setVolume(audio.AudioVolumeType.RINGTONE,maxVol); + audioManager.getVolume(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data == lowVol){ + console.info('AudioFrameworkTest: Media getVolume Promise: ENAME : PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getVolume Promise: ENAME : FAIL :' + data); + expect(false).assertTrue(); + } + + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_026 + * @tc.name : setVolume - Media - Callback - Change Ringtone vol + * @tc.desc : Setvol to 14 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_026', 0, async function (done) { + + audioManager.setVolume(audio.AudioVolumeType.MEDIA,highVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ENAME : ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : ENAME : Media setVolume successful `); + audioManager.setVolume(audio.AudioVolumeType.RINGTONE,lowVol); + audioManager.getVolume(audio.AudioVolumeType.MEDIA, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media: ENAME : failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == highVol){ + console.info('AudioFrameworkTest: callback : Media getVolume: ENAME : PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media getVolume: ENAME : FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_027 + * @tc.name : setVolume - Ringtone - Promise - Change Media vol + * @tc.desc : Setvol to 14 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_027', 0, async function (done) { + + const promise = audioManager.setVolume(audio.AudioVolumeType.RINGTONE,highVol); + promise.then(async function (data) { + console.info('AudioFrameworkTest: Ringtone setVolume promise: ENAME: successful'); + audioManager.setVolume(audio.AudioVolumeType.MEDIA,lowVol); + audioManager.getVolume(audio.AudioVolumeType.RINGTONE).then(async function (data) { + if(data == 5){ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: ENAME: PASS :' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getVolume Promise: ENAME: FAIL :' + data); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_SetVolume_028 + * @tc.name : setVolume - Ringtone - Callback - Change Media vol + * @tc.desc : Setvol to 5 + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_SetVolume_028', 0, async function (done) { + audioManager.setVolume(audio.AudioVolumeType.RINGTONE,lowVol, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: failed to set volume: Callback: ENAME: ${err.message}`); + expect(false).assertTrue(); + } + console.info(`AudioFrameworkTest: callback : ENAME: Ringtone setVolume successful `); + audioManager.setVolume(audio.AudioVolumeType.MEDIA,highVol); + audioManager.getVolume(audio.AudioVolumeType.RINGTONE, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone: ENAME: failed to get volume ${err.message}`); + expect(false).assertTrue(); + } + else if(value == lowVol){ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: ENAME: PASS :' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone getVolume: ENAME: FAIL :' + value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_001 + * @tc.name : getMaxVolume - Media - Promise + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_001', 0, async function (done) { + + const promise = audioManager.getMaxVolume(audioMedia); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Media getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_002 + * @tc.name : getMaxVolume - Media - Callback + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_002', 0, async function (done) { + + audioManager.getMaxVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMaxVolume ${err.message}`); + return; + } + else if (value=maxVol){ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + + }) + + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_003 + * @tc.name : getMaxVolume - Ringtone - Promise + * @tc.desc : getMaxVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_003', 0, async function (done) { + const promise = audioManager.getMaxVolume(audioRingtone); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_004 + * @tc.name : getMaxVolume - Ringtone - Callback + * @tc.desc : getMaxVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_004', 0, async function (done) { + audioManager.getMaxVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMaxVolume ${err.message}`); + return; + } + else if (value==maxVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_005 + * @tc.name : getMaxVolume - Media - Promise - Change Ringtone Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_005', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + const promise = audioManager.getMaxVolume(audioMedia); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Media getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_006 + * @tc.name : getMaxVolume - Ringtone - Promise - Change Media Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_006', 0, async function (done) { + audioManager.setVolume(audioMedia,lowVol); + const promise = audioManager.getMaxVolume(audioRingtone); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_007 + * @tc.name : getMaxVolume - Media - Callback- Change Ringtone Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_007', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + audioManager.getMaxVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMaxVolume ${err.message}`); + return; + } + else if (value=maxVol){ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_008 + * @tc.name : getMaxVolume - Ringtone - Callback - Callback- Change media Volume and check + * @tc.desc : getMaxVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_008', 0, async function (done) { + audioManager.setVolume(audioMedia,lowVol); + audioManager.getMaxVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMaxVolume ${err.message}`); + return; + } + else if (value==maxVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_009 + * @tc.name : getMaxVolume - Media - Promise - Change media Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_009', 0, async function (done) { + audioManager.setVolume(audioMedia,5); + const promise = audioManager.getMaxVolume(audioMedia); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Media getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_010 + * @tc.name : getMaxVolume - Ringtone - Promise - Change Ringtone Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_010', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + const promise = audioManager.getMaxVolume(audioRingtone); + promise.then(async function (data) { + if (data==maxVol){ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMaxVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_011 + * @tc.name : getMaxVolume - Media - Callback- Change media Volume and check + * @tc.desc : getMaxVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_011', 0, async function (done) { + audioManager.setVolume(audioMedia,highVol); + audioManager.getMaxVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMaxVolume ${err.message}`); + return; + } + else if (value=maxVol){ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMaxVolume_012 + * @tc.name : getMaxVolume - Ringtone - Callback - Callback- Change ringtone Volume and check + * @tc.desc : getMaxVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMaxVolume_012', 0, async function (done) { + audioManager.setVolume(audioRingtone,highVol); + audioManager.getMaxVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMaxVolume ${err.message}`); + return; + } + else if (value==maxVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMaxVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_001 + * @tc.name : getMinVolume - Media - Promise + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_001', 0, async function (done) { + + const promise = audioManager.getMinVolume(audioMedia); + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Media getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_002 + * @tc.name : getMinVolume - Media - Callback + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_002', 0, async function (done) { + + audioManager.getMinVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_003 + * @tc.name : getMinVolume - Ringtone - Promise + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_003', 0, async function (done) { + + const promise = audioManager.getMinVolume(audioRingtone); + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_004 + * @tc.name : getMinVolume - Ringtone - Callback + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_004', 0, async function (done) { + + audioManager.getMinVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_005 + * @tc.name : getMinVolume - Media - Promise - Change Ringtone Volume and check + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_005', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + const promise = audioManager.getMinVolume(audioMedia); + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Media getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_006 + * @tc.name : getMinVolume - Media - Callback - Change Ringtone Volume and check + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_006', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + audioManager.getMinVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_007 + * @tc.name : getMinVolume - Ringtone - Promise - Change Media Volume and check + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_007', 0, async function (done) { + audioManager.setVolume(audioMedia,highVol); + const promise = audioManager.getMinVolume(audioRingtone); + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_008 + * @tc.name : getMinVolume - Ringtone - Callback - Change Media Volume and check + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_008', 0, async function (done) { + audioManager.setVolume(audioMedia,lowVol); + audioManager.getMinVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_009 + * @tc.name : getMinVolume - Media - Promise - Change Media Volume and check + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_009', 0, async function (done) { + audioManager.setVolume(audioMedia,lowVol); + const promise = audioManager.getMinVolume(audioMedia); + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Media getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Media getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_010 + * @tc.name : getMinVolume - Media - Callback - Change Media Volume and check + * @tc.desc : getMinVolume for Media + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_010', 0, async function (done) { + audioManager.setVolume(audioMedia,highVol); + audioManager.getMinVolume(audioMedia, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Media : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Media: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_011 + * @tc.name : getMinVolume - Ringtone - Promise - Change Ringtone Volume and check + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_011', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + const promise = audioManager.getMinVolume(audioRingtone) + promise.then(async function (data) { + if (data==minVol){ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : PASS:' + data); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Ringtone getMinVolume promise : FAIL: ' + data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getMinVolume_012 + * @tc.name : getMinVolume - Ringtone - Callback - Change Ringtone Volume and check + * @tc.desc : getMinVolume for Ringtone + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getMinVolume_012', 0, async function (done) { + audioManager.setVolume(audioRingtone,lowVol); + audioManager.getMinVolume(audioRingtone, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: callback : Ringtone : failed to getMinVolume ${err.message}`); + return; + } + else if (value==minVol){ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : PASS:' + value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: callback : Ringtone: getMinVolume : FAIL: ' + value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_001 + * @tc.name : getDevices - Output device - Promise + * @tc.desc : getDevices - Output device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_001', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(1); //Getting all Output devices Enumb 1 = OUTPUT_DEVICES_FLAG + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices OUTPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_002 + * @tc.name : getDevices - Input device - Promise + * @tc.desc : getDevices - Input device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_002', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(2); //Getting all Input Devices ENUM 2 = INPUT_DEVICES_FLAG + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices INPUT_DEVICES_FLAG'); + + console.info('AudioFrameworkTest: Promise: getDevices INPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : INPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : INPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_003 + * @tc.name : getDevices - ALL device - Promise + * @tc.desc : getDevices - ALL device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_003', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(3); //Getting all devies connected 3 = ALL_DEVICES_FLAG + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices ALL_DEVICES_FLAG'); + + console.info('AudioFrameworkTest: Promise: getDevices ALL_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : ALL_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : ALL_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_004 + * @tc.name : getDevices - Output device - Callback + * @tc.desc : getDevices - Output device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_004', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(1, (err, value) => { //Getting all Output devices Enumb 1 = OUTPUT_DEVICES_FLAG + + console.info('AudioFrameworkTest: Callback: getDevices OUTPUT_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: OUTPUT_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices OUTPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : OUTPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : OUTPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_005 + * @tc.name : getDevices - Input device - Callback + * @tc.desc : getDevices - Input device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_005', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(2, (err, value) => { //Getting all Input Devices ENUM 2 = INPUT_DEVICES_FLAG + + console.info('AudioFrameworkTest: Callback: getDevices INPUT_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: INPUT_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices INPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : INPUT_DEVICES_FLAG: PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : INPUT_DEVICES_FLAG: FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_006 + * @tc.name : getDevices - ALL device - Callback + * @tc.desc : getDevices - ALL device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_006', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(3, (err, value) => { //Getting all devies connected 3 = ALL_DEVICES_FLAG + + console.info('AudioFrameworkTest: Callback: getDevices ALL_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: ALL_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices ALL_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : ALL_DEVICES_FLAG: PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : ALL_DEVICES_FLAG: FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_007 + * @tc.name : getDevices - Output device - Promise - ENAME + * @tc.desc : getDevices - Output device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_007', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG) + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices OUTPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : OUTPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_008 + * @tc.name : getDevices - Input device - Promise - ENAME + * @tc.desc : getDevices - Input device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_008', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(audio.DeviceFlag.INPUT_DEVICES_FLAG); + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices INPUT_DEVICES_FLAG'); + + console.info('AudioFrameworkTest: Promise: getDevices INPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : INPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : INPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_009 + * @tc.name : getDevices - ALL device - Promise - ENAME + * @tc.desc : getDevices - ALL device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_009', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + const promise = audioManager.getDevices(audio.DeviceFlag.ALL_DEVICES_FLAG); + promise.then(async function (value) { + + console.info('AudioFrameworkTest: Promise: getDevices ALL_DEVICES_FLAG'); + + console.info('AudioFrameworkTest: Promise: getDevices ALL_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Promise: getDevices : ALL_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getDevices : ALL_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_010 + * @tc.name : getDevices - Output device - Callback - ENAME + * @tc.desc : getDevices - Output device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_010', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(audio.DeviceFlag.OUTPUT_DEVICES_FLAG, (err, value) => { + + console.info('AudioFrameworkTest: Callback: getDevices OUTPUT_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: OUTPUT_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices OUTPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : OUTPUT_DEVICES_FLAG : PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : OUTPUT_DEVICES_FLAG : FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_011 + * @tc.name : getDevices - Input device - Callback - ENAME + * @tc.desc : getDevices - Input device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_011', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(audio.DeviceFlag.INPUT_DEVICES_FLAG, (err, value) => { + + console.info('AudioFrameworkTest: Callback: getDevices INPUT_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: INPUT_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices INPUT_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : INPUT_DEVICES_FLAG: PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : INPUT_DEVICES_FLAG: FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getDevices_012 + * @tc.name : getDevices - ALL device - Callback - ENAME + * @tc.desc : getDevices - ALL device + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getDevices_012', 0, async function (done) { + + deviceRoleValue = null; + deviceTypeValue = null; + audioManager.getDevices(audio.DeviceFlag.ALL_DEVICES_FLAG, (err, value) => { + + console.info('AudioFrameworkTest: Callback: getDevices ALL_DEVICES_FLAG'); + + if (err) { + console.error(`AudioFrameworkTest: Callback: ALL_DEVICES_FLAG: failed to get devices ${err.message}`); + return; + } + + console.info('AudioFrameworkTest: Callback: getDevices ALL_DEVICES_FLAG'); + value.forEach(displayDeviceProp); + + if (deviceTypeValue != null && deviceRoleValue != null){ + console.info('AudioFrameworkTest: Callback: getDevices : ALL_DEVICES_FLAG: PASS'); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getDevices : ALL_DEVICES_FLAG: FAIL'); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_001 + * @tc.name : setRingerMode - Normal Mode - Promise + * @tc.desc : setRingerMode - Set Ring more to Normal Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_001', 0, async function (done) { + + const promise = audioManager.setRingerMode(2); //Setting Ringtone Mode to Normal ENUM 2 = RINGER_MODE_NORMAL + promise.then(async function (value) { + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL'); + audioManager.getRingerMode().then(async function (value){ + if(value==2){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_002 + * @tc.name : setRingerMode - Silent Mode - Promise + * @tc.desc : setRingerMode - Set Ring more to Silent Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_002', 0, async function (done) { + + const promise = audioManager.setRingerMode(0); //Setting Ringtone Mode to Silent ENUM 0 = RINGER_MODE_SILENT + promise.then(async function (value){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT'); + audioManager.getRingerMode().then(async function (value){ + if(value==0){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_003 + * @tc.name : setRingerMode - Vibration Mode - Promise + * @tc.desc : setRingerMode - Set Ring more to Vibration Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_003', 0, async function (done) { + + const promise = audioManager.setRingerMode(1); //Setting Ringtone Mode to Vibration ENUM 1 = RINGER_MODE_VIBRATE + promise.then(async function (value){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE'); + audioManager.getRingerMode().then(async function (value){ + if(value==1){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_004 + * @tc.name : setRingerMode - Normal Mode - Callback + * @tc.desc : setRingerMode - Set Ring more to Normal Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_004', 0, async function (done) { + + audioManager.setRingerMode(2, (err, value) => { //Setting Ringtone Mode to Normal ENUM 2 = RINGER_MODE_NORMAL + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + else if(value==2){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_NORMAL: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_NORMAL: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_005 + * @tc.name : setRingerMode - Silent Mode - Callback + * @tc.desc : setRingerMode - Set Ring more to Silent Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_005', 0, async function (done) { + + audioManager.setRingerMode(0, (err, value) => { //Setting Ringtone Mode to Silent ENUM 0 = RINGER_MODE_SILENT + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + if(value==0){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_SILENT: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_SILENT: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_006 + * @tc.name : setRingerMode - Vibration Mode - Callback + * @tc.desc : setRingerMode - Set Ring more to Vibration Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_006', 0, async function (done) { + + audioManager.setRingerMode(1, (err, value) => { //Setting Ringtone Mode to Vibration ENUM 1 = RINGER_MODE_VIBRATE + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + if(value==1){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_VIBRATE: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_VIBRATE: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_007 + * @tc.name : setRingerMode - Normal Mode - Promise - ENAME + * @tc.desc : setRingerMode - Set Ring more to Normal Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_007', 0, async function (done) { + + const promise = audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL'); + audioManager.getRingerMode().then(async function (value){ + if(value==audio.AudioRingMode.RINGER_MODE_NORMAL){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_NORMAL: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_008 + * @tc.name : setRingerMode - Silent Mode - Promise - ENAME + * @tc.desc : setRingerMode - Set Ring more to Silent Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_008', 0, async function (done) { + + const promise = audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_SILENT); + promise.then(async function (value){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT'); + audioManager.getRingerMode().then(async function (value){ + if(value==audio.AudioRingMode.RINGER_MODE_SILENT){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_SILENT: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_009 + * @tc.name : setRingerMode - Vibration Mode - Promise - NAME + * @tc.desc : setRingerMode - Set Ring more to Vibration Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_009', 0, async function (done) { + + const promise = audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_VIBRATE); + promise.then(async function (value){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE'); + audioManager.getRingerMode().then(async function (value){ + if(value==audio.AudioRingMode.RINGER_MODE_VIBRATE){ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: setRingerMode​ RINGER_MODE_VIBRATE: FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_010 + * @tc.name : setRingerMode - Normal Mode - Callback - ENAME + * @tc.desc : setRingerMode - Set Ring more to Normal Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_010', 0, async function (done) { + + audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_NORMAL, (err, value) => { + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_NORMAL: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value==audio.AudioRingMode.RINGER_MODE_NORMAL){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_NORMAL: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_NORMAL: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_0011 + * @tc.name : setRingerMode - Silent Mode - Callback - ENAME + * @tc.desc : setRingerMode - Set Ring more to Silent Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_011', 0, async function (done) { + + audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_SILENT, (err, value) => { + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_SILENT: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + if(value==audio.AudioRingMode.RINGER_MODE_SILENT){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_SILENT: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_SILENT: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setRingerMode_012 + * @tc.name : setRingerMode - Vibration Mode - Callback + * @tc.desc : setRingerMode - Set Ring more to Vibration Mode + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setRingerMode_012', 0, async function (done) { + + audioManager.setRingerMode(audio.AudioRingMode.RINGER_MODE_VIBRATE, (err, value) => { + + console.info('AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE'); + + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + audioManager.getRingerMode((err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : setRingerMode​ RINGER_MODE_VIBRATE: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + + if(value==audio.AudioRingMode.RINGER_MODE_VIBRATE){ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_VIBRATE: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: setRingerMode​ RINGER_MODE_VIBRATE: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_001 + * @tc.name : mute - Media - Promise + * @tc.desc : mute - Media - Promise - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_001', 0, async function (done) { + await audioManager.mute(audioMedia,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Promise: TRUE'); + audioManager.isMute(audioMedia).then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: TRUE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_006 + * @tc.name : mute - Media - callback + * @tc.desc : mute - Media - callback - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_006', 0, async function (done) { + audioManager.mute(audioMedia,false, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Callback : FALSE'); + audioManager.isMute(audioMedia, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : FALSE: Media : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: FALSE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_002 + * @tc.name : mute - Media - callback + * @tc.desc : mute - Media - callback - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_002', 0, async function (done) { + audioManager.mute(audioMedia,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Callback : TRUE'); + audioManager.isMute(audioMedia, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : TRUE: Media : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: TRUE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_005 + * @tc.name : mute - Media - Promise + * @tc.desc : mute - Media - Promise - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_005', 0, async function (done) { + await audioManager.mute(audioMedia,false).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Promise: FALSE'); + audioManager.isMute(audioMedia).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: FALSE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: FALSE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_003 + * @tc.name : mute - Ringtone - Promise + * @tc.desc : mute - Ringtone - Promise - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_003', 0, async function (done) { + await audioManager.mute(audioRingtone,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Promise: TRUE'); + audioManager.isMute(audioRingtone).then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: TRUE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_008 + * @tc.name : mute - Ringtone - callback + * @tc.desc : mute - Ringtone - callback - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_008', 0, async function (done) { + + audioManager.mute(audioRingtone,false, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Callback : FALSE'); + audioManager.isMute(audioRingtone, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : FALSE: Ringtone : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: FALSE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_004 + * @tc.name : mute - Ringtone - callback + * @tc.desc : mute - Ringtone - callback - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_004', 0, async function (done) { + + audioManager.mute(audioRingtone,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Callback : TRUE'); + audioManager.isMute(audioRingtone, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : TRUE: Ringtone : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: TRUE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_007 + * @tc.name : mute - Ringtone - Promise + * @tc.desc : mute - Ringtone - Promise - disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_007', 0, async function (done) { + + await audioManager.mute(audioRingtone,false).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Promise: FALSE'); + audioManager.isMute(audioRingtone).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: FALSE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Rington: FALSE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_009 + * @tc.name : mute - Media - Promise - ENAME + * @tc.desc : mute - Media - Promise - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_009', 0, async function (done) { + await audioManager.mute(audio.AudioVolumeType.MEDIA,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Promise: TRUE'); + audioManager.isMute(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: TRUE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_015 + * @tc.name : mute - Media - callback - ENAME + * @tc.desc : mute - Media - callback - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_015', 0, async function (done) { + audioManager.mute(audio.AudioVolumeType.MEDIA,false, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Media: ENAME: Callback : FALSE'); + audioManager.isMute(audio.AudioVolumeType.MEDIA, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : FALSE: Media : ENAME: failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: ENAME: FALSE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: ENAME: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_010 + * @tc.name : mute - Media - callback - ENAME: + * @tc.desc : mute - Media - callback - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_010', 0, async function (done) { + audioManager.mute(audio.AudioVolumeType.MEDIA,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Media: ENAME: Callback : TRUE'); + audioManager.isMute(audio.AudioVolumeType.MEDIA, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : TRUE: Media : ENAME: failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: ENAME: TRUE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_011 + * @tc.name : mute - Media - Promise - ENAME + * @tc.desc : mute - Media - Promise - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_011', 0, async function (done) { + await audioManager.mute(audio.AudioVolumeType.MEDIA,false).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: ENAME: Promise: FALSE'); + audioManager.isMute(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_012 + * @tc.name : mute - Ringtone - Promise - ENAME + * @tc.desc : mute - Ringtone - Promise - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_012', 0, async function (done) { + await audioManager.mute(audio.AudioVolumeType.RINGTONE,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: ENAME: Promise: TRUE'); + audioManager.isMute(audio.AudioVolumeType.RINGTONE).then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: ENAME: TRUE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_016 + * @tc.name : mute - Ringtone - callback - ENAME + * @tc.desc : mute - Ringtone - callback - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_016', 0, async function (done) { + + audioManager.mute(audio.AudioVolumeType.RINGTONE,false, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: ENAME: Callback : FALSE'); + audioManager.isMute(audio.AudioVolumeType.RINGTONE, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : FALSE: Ringtone : ENAME: failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: ENAME: FALSE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: ENAME: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_013 + * @tc.name : mute - Ringtone - callback - ENAME + * @tc.desc : mute - Ringtone - callback - Enable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_013', 0, async function (done) { + + audioManager.mute(audio.AudioVolumeType.RINGTONE,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Set Stream Mute: Media: Callback: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: ENAME: Callback : TRUE'); + audioManager.isMute(audio.AudioVolumeType.RINGTONE, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : TRUE: Ringtone : ENAME: failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: ENAME: TRUE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_014 + * @tc.name : mute - Media - Promise - ENAME: + * @tc.desc : mute - Media - Promise - Disable mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_014', 0, async function (done) { + await audioManager.mute(audio.AudioVolumeType.MEDIA,false).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: ENAME: Promise: FALSE'); + audioManager.isMute(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: ENAME: FALSE: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_017 + * @tc.name : mute - Media - Promise - SetVolume + * @tc.desc : mute - Media - Promise - Enable mute -SetVolume + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_017', 0, async function (done) { + await audioManager.mute(audioMedia,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Media: Promise: TRUE'); + audioManager.setVolume(audioMedia,lowVol); + audioManager.isMute(audioMedia).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: SetVolume: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Media: SetVolume: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Media: SetVolume: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_018 + * @tc.name : mute - Media - callback - SetVolume + * @tc.desc : mute - Media - callback - Enable mute - SetVolume + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_018', 0, async function (done) { + audioManager.mute(audioMedia,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : SetVolume: Media : failed to set Mute Status ${err.message}`); + expect(false).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Set Stream Mute: Media: Callback : TRUE'); + audioManager.setVolume(audioMedia,highVol); + audioManager.isMute(audioMedia, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : SetVolume: Media : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: SetVolume: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Media: SetVolume: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_019 + * @tc.name : mute - Ringtone - Promise - SetVolume + * @tc.desc : mute - Ringtone - Promise - Enable mute - SetVolume + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_019', 0, async function (done) { + await audioManager.mute(audioRingtone,true).then(async function (data) { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Promise: SetVolume'); + audioManager.setVolume(audioRingtone,highVol); + audioManager.isMute(audioRingtone).then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: SetVolume: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: SetVolume: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: Is Stream Mute Ringtone: SetVolume: ERROR:' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_mute_020 + * @tc.name : mute - Ringtone - callback - SetVolume + * @tc.desc : mute - Ringtone - callback - Enable mute - SetVolume + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_mute_020', 0, async function (done) { + + audioManager.mute(audioRingtone,true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : SetVolume: Ringtone : failed to set Mute Status ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: Set Stream Mute: Ringtone: Callback : SetVolume'); + audioManager.setVolume(audioRingtone,lowVol); + audioManager.isMute(audioRingtone, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : SetVolume: Ringtone : failed to get Mute Status ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: SetVolume: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : Is Stream Mute Ringtone: SetVolume: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_001 + * @tc.name : isActive - Media - Promise + * @tc.desc : isActive - Media - Promise - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_001', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Media: NOTE audio plaback as MEDIA needs to be played for the test case to PASS'); + const promise = audioManager.isActive(audioMedia); + promise.then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: isActive: Media: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_002 + * @tc.name : isActive - Media - Callback + * @tc.desc : isActive - Media - Callback - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_002', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Media: NOTE audio plaback as MEDIA needs to be played for the test case to PASS'); + audioManager.isActive(audioMedia, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Media : isActive: failed ${err.message}`); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback: isActive: Media: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_003 + * @tc.name : isActive - Ringtone - Promise + * @tc.desc : isActive - Ringtone - Promise - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_003', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Ringtone: NOTE audio plaback as Ringtone needs to be played for the test case to PASS'); + const promise = audioManager.isActive(audioRingtone); + promise.then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_004 + * @tc.name : isActive - Ringtone - Callback + * @tc.desc : isActive - Ringtone - Callback - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_004', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Ringtone: NOTE audio plaback as Ringtone needs to be played for the test case to PASS'); + audioManager.isActive(audioRingtone, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Ringtone : isActive: failed ${err.message}`); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_005 + * @tc.name : isActive - Media - Promise + * @tc.desc : isActive - Media - Promise - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_005', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Media: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + const promise = audioManager.isActive(audioMedia); + promise.then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: isActive: Media: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_006 + * @tc.name : isActive - Media - Callback + * @tc.desc : isActive - Media - Callback - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_006', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Media: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + audioManager.isActive(audioMedia, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Media : isActive: failed ${err.message}`); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback: isActive: Media: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Media: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_007 + * @tc.name : isActive - Ringtone - Promise + * @tc.desc : isActive - Ringtone - Promise - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_007', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Ringtone: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + const promise = audioManager.isActive(audioRingtone); + promise.then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_008 + * @tc.name : isActive - Ringtone - Callback + * @tc.desc : isActive - Ringtone - Callback - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_008', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Ringtone: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + audioManager.isActive(audioRingtone, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Ringtone : isActive: failed ${err.message}`); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_009 + * @tc.name : isActive - Media - Promise - ENAME + * @tc.desc : isActive - Media - Promise - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_009', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Media: ENAME: NOTE audio plaback as MEDIA needs to be played for the test case to PASS'); + const promise = audioManager.isActive(audio.AudioVolumeType.MEDIA).then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: isActive: Media: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_010 + * @tc.name : isActive - Media - Callback - ENAME + * @tc.desc : isActive - Media - Callback - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_010', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Media: ENAME: NOTE audio plaback as MEDIA needs to be played for the test case to PASS'); + audioManager.isActive(audio.AudioVolumeType.MEDIA, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Media : isActive: ENAME: failed ${err.message}`); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback: isActive: Media: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_011 + * @tc.name : isActive - Ringtone - Promise - ENAME + * @tc.desc : isActive - Ringtone - Promise - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_011', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Ringtone: ENAME: NOTE audio plaback as Ringtone needs to be played for the test case to PASS'); + const promise = audioManager.isActive(audio.AudioVolumeType.RINGTONE); + promise.then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_012 + * @tc.name : isActive - Ringtone - Callback - ENAME + * @tc.desc : isActive - Ringtone - Callback - When stream is playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_012', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Ringtone: ENAME: NOTE audio plaback as Ringtone needs to be played for the test case to PASS'); + audioManager.isActive(audio.AudioVolumeType.RINGTONE, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Ringtone : isActive: ENAME: failed ${err.message}`); + return; + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_013 + * @tc.name : isActive - Media - Promise - ENAME: + * @tc.desc : isActive - Media - Promise - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_013', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Media: ENAME: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + const promise = audioManager.isActive(audio.AudioVolumeType.MEDIA); + promise.then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: isActive: Media: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_014 + * @tc.name : isActive - Media - Callback - ENAME + * @tc.desc : isActive - Media - Callback - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_014', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Media: ENAME: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + audioManager.isActive(audio.AudioVolumeType.MEDIA, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Media : ENAME: isActive: failed ${err.message}`); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback: isActive: Media: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Media: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_015 + * @tc.name : isActive - Ringtone - Promise - ENAME + * @tc.desc : isActive - Ringtone - Promise - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_015', 0, async function (done) { + console.log('AudioFrameworkTest: Promise : isActive Ringtone: ENAME: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + const promise = audioManager.isActive(audio.AudioVolumeType.RINGTONE); + promise.then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isActive: Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_isActive_016 + * @tc.name : isActive - Ringtone - Callback - ENAME + * @tc.desc : isActive - Ringtone - Callback - When stream is NOT playing + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_isActive_016', 0, async function (done) { + console.log('AudioFrameworkTest: Callback : isActive Ringtone: ENAME: NOTE: audio NOT PLAYING as MEDIA for the test case to PASS'); + audioManager.isActive(audio.AudioVolumeType.RINGTONE, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : Ringtone : ENAME: isActive: failed ${err.message}`); + return; + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: ENAME: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback: isActive: Ringtone: ENAME: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setMicrophoneMute_001 + * @tc.name : setMicrophoneMute - true - Promise + * @tc.desc : Enable mic mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setMicrophoneMute_001', 0, async function (done) { + await audioManager.setMicrophoneMute(true).then(async function (data) { + console.log('AudioFrameworkTest: setMicrophoneMute: Promise: TRUE'); + audioManager.isMicrophoneMute().then(async function (data) { + if(data==true){ + console.log('AudioFrameworkTest: Promise: isMicrophoneMute: TRUE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isMicrophoneMute: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: setMicrophoneMute: TRUE: FAIL: Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setMicrophoneMute_002 + * @tc.name : setMicrophoneMute - false - Promise + * @tc.desc : Disable mic mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setMicrophoneMute_002', 0, async function (done) { + await audioManager.setMicrophoneMute(false).then(async function (data) { + console.log('AudioFrameworkTest: setMicrophoneMute: Promise: FALSE'); + audioManager.isMicrophoneMute().then(async function (data) { + if(data==false){ + console.log('AudioFrameworkTest: Promise: isMicrophoneMute: FALSE: PASS:'+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Promise: isMicrophoneMute: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Promise: setMicrophoneMute: FALSE: FAIL: Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setMicrophoneMute_003 + * @tc.name : setMicrophoneMute - true - Callback + * @tc.desc : Enable mic mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setMicrophoneMute_003', 0, async function (done) { + audioManager.setMicrophoneMute(true, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: setMicrophoneMute: Callback : TRUE: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: setMicrophoneMute: Callback : TRUE'); + audioManager.isMicrophoneMute((err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : TRUE: isMicrophoneMute : Error ${err.message}`); + expect(false).assertTrue(); + } + else if(data==true){ + console.log('AudioFrameworkTest: Callback : isMicrophoneMute: TRUE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : isMicrophoneMute: TRUE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setMicrophoneMute_004 + * @tc.name : setMicrophoneMute - false - Callback + * @tc.desc : Disable mic mute + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setMicrophoneMute_004', 0, async function (done) { + audioManager.setMicrophoneMute(false, (err, data) => { + if (err) { + console.error(`AudioFrameworkTest: setMicrophoneMute: Callback : FALSE: Error : ${err.message}`); + expect(false).assertTrue(); + } + else { + console.log('AudioFrameworkTest: setMicrophoneMute: Callback : FALSE'); + audioManager.isMicrophoneMute((err, data) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : FALSE: isMicrophoneMute : Error ${err.message}`); + expect(false).assertTrue(); + } + else if(data==false){ + console.log('AudioFrameworkTest: Callback : isMicrophoneMute: FALSE: PASS: '+data); + expect(true).assertTrue(); + } + else{ + console.log('AudioFrameworkTest: Callback : isMicrophoneMute: FALSE: FAIL: '+data); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_001 + * @tc.name : setDeviceActive - SPEAKER - deactivate - Promise + * @tc.desc : Deactivate speaker - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_001', 0, async function (done) { + await audioManager.setDeviceActive(1,false).then( //Setting device active ENUM 1 = SPEAKER + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : SPEAKER: Deactivate'); + audioManager.isDeviceActive(audio.DeviceType.SPEAKER).then(async function (value){ + if(value==false){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Deactivate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_002 + * @tc.name : setDeviceActive - SPEAKER - Activate - Promise + * @tc.desc : Activate speaker - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_002', 0, async function (done) { + await audioManager.setDeviceActive(audio.DeviceType.SPEAKER,true).then( + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : SPEAKER: Activate'); + audioManager.isDeviceActive(1).then(async function (value){ + if(value==true){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Activate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Activate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : SPEAKER: Activate : FAIL :Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_003 + * @tc.name : setDeviceActive - WIRED_HEADSET - deactivate - Promise + * @tc.desc : Deactivate WIRED_HEADSET - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_003', 0, async function (done) { + await audioManager.setDeviceActive(2,false).then( //Setting device active ENUM 2 = WIRED_HEADSET + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : WIRED_HEADSET: Deactivate'); + audioManager.isDeviceActive(audio.DeviceType.WIRED_HEADSET).then(async function (value){ + if(value==false){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Deactivate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_004 + * @tc.name : setDeviceActive - WIRED_HEADSET - Activate - Promise + * @tc.desc : Activate WIRED_HEADSET - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_004', 0, async function (done) { + await audioManager.setDeviceActive(audio.DeviceType.WIRED_HEADSET,true).then( + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : WIRED_HEADSET: Activate'); + audioManager.isDeviceActive(2).then(async function (value){ + if(value==true){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Activate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Activate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : WIRED_HEADSET: Activate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_005 + * @tc.name : setDeviceActive - BLUETOOTH_SCO - deactivate - Promise + * @tc.desc : Deactivate BLUETOOTH_SCO - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_005', 0, async function (done) { + await audioManager.setDeviceActive(3,false).then( //Setting device active ENUM 3 = BLUETOOTH_SCO + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : BLUETOOTH_SCO: Deactivate'); + audioManager.isDeviceActive(audio.DeviceType.BLUETOOTH_SCO).then(async function (value){ + if(value==false){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Deactivate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_006 + * @tc.name : setDeviceActive - BLUETOOTH_SCO - Activate - Promise + * @tc.desc : Activate BLUETOOTH_SCO - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_006', 0, async function (done) { + await audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_SCO,true).then( + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : BLUETOOTH_SCO: Activate'); + audioManager.isDeviceActive(3).then(async function (value){ + if(value==true){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Activate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Activate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_SCO: Activate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_007 + * @tc.name : setDeviceActive - BLUETOOTH_A2DP - deactivate - Promise + * @tc.desc : Deactivate BLUETOOTH_A2DP - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_007', 0, async function (done) { + await audioManager.setDeviceActive(4,false).then( //Setting device active ENUM 4 = BLUETOOTH_A2DP + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : BLUETOOTH_A2DP: Deactivate'); + audioManager.isDeviceActive(audio.DeviceType.BLUETOOTH_A2DP).then(async function (value){ + if(value==false){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Deactivate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_008 + * @tc.name : setDeviceActive - BLUETOOTH_A2DP - Activate - Promise + * @tc.desc : Activate BLUETOOTH_A2DP - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_008', 0, async function (done) { + await audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_A2DP,true).then( + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : BLUETOOTH_A2DP: Activate'); + audioManager.isDeviceActive(4).then(async function (value){ + if(value==true){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Activate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Activate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : BLUETOOTH_A2DP: Activate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_009 + * @tc.name : setDeviceActive - MIC - deactivate - Promise + * @tc.desc : Deactivate MIC - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_009', 0, async function (done) { + await audioManager.setDeviceActive(5,false).then( //Setting device active ENUM 5 = MIC + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : MIC: Deactivate'); + audioManager.isDeviceActive(audio.DeviceType.MIC).then(async function (value){ + if(value==false){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Deactivate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_010 + * @tc.name : setDeviceActive - MIC - Activate - Promise + * @tc.desc : Activate MIC - Promise + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_010', 0, async function (done) { + await audioManager.setDeviceActive(audio.DeviceType.MIC,true).then( + async function (value){ + console.info('AudioFrameworkTest: Device Test: Promise : setDeviceActive : MIC: Activate'); + audioManager.isDeviceActive(5).then(async function (value){ + if(value==true){ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Activate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Activate : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }).catch((err) => { + console.info('AudioFrameworkTest: Device Test: Promise : isDeviceActive : MIC: Activate : FAIL : Error :' + err.message); + expect(false).assertTrue(); + }); + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_011 + * @tc.name : setDeviceActive - SPEAKER - deactivate - Callback + * @tc.desc : Deactivate speaker - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_011', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.SPEAKER,false, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : SPEAKER: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : SPEAKER: Active'); + audioManager.isDeviceActive(1,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==false){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_012 + * @tc.name : setDeviceActive - SPEAKER - deactivate - Callback + * @tc.desc : Activate speaker - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_012', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.SPEAKER,true, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : SPEAKER: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : SPEAKER: Active'); + audioManager.isDeviceActive(1,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==true){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Active : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : SPEAKER: Active : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_013 + * @tc.name : setDeviceActive - WIRED_HEADSET - deactivate - Callback + * @tc.desc : Deactivate WIRED_HEADSET - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_013', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.WIRED_HEADSET,false, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : WIRED_HEADSET: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : WIRED_HEADSET: Active'); + audioManager.isDeviceActive(2,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==false){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_014 + * @tc.name : setDeviceActive - WIRED_HEADSET - deactivate - Callback + * @tc.desc : Activate WIRED_HEADSET - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_014', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.WIRED_HEADSET,true, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : WIRED_HEADSET: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : WIRED_HEADSET: Active'); + audioManager.isDeviceActive(2,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==true){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Active : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : WIRED_HEADSET: Active : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_015 + * @tc.name : setDeviceActive - BLUETOOTH_SCO - deactivate - Callback + * @tc.desc : Deactivate BLUETOOTH_SCO - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_015', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_SCO,false, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_SCO: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_SCO: Active'); + audioManager.isDeviceActive(3,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==false){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_016 + * @tc.name : setDeviceActive - BLUETOOTH_SCO - deactivate - Callback + * @tc.desc : Activate BLUETOOTH_SCO - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_016', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_SCO,true, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_SCO: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_SCO: Active'); + audioManager.isDeviceActive(3,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==true){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Active : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_SCO: Active : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_017 + * @tc.name : setDeviceActive - BLUETOOTH_A2DP - deactivate - Callback + * @tc.desc : Deactivate BLUETOOTH_A2DP - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_017', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_A2DP,false, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_A2DP: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_A2DP: Active'); + audioManager.isDeviceActive(4,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==false){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + //await sleep(20); + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_018 + * @tc.name : setDeviceActive - BLUETOOTH_A2DP - deactivate - Callback + * @tc.desc : Activate BLUETOOTH_A2DP - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_018', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.BLUETOOTH_A2DP,true, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_A2DP: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : BLUETOOTH_A2DP: Active'); + audioManager.isDeviceActive(4,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==true){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Active : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : BLUETOOTH_A2DP: Active : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_019 + * @tc.name : setDeviceActive - MIC - deactivate - Callback + * @tc.desc : Deactivate MIC - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_019', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.MIC,false, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : MIC: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : MIC: Active'); + audioManager.isDeviceActive(5,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Deactivate: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==false){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Deactivate : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Deactivate : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setDeviceActive_020 + * @tc.name : setDeviceActive - MIC - deactivate - Callback + * @tc.desc : Activate MIC - Callback + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setDeviceActive_020', 0, async function (done) { + audioManager.setDeviceActive(audio.DeviceType.MIC,true, (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : setDeviceActive : MIC: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else { + console.info('AudioFrameworkTest: Device Test: Callback : setDeviceActive : MIC: Active'); + audioManager.isDeviceActive(5,(err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Active: Error: ${err.message}`); + expect(false).assertTrue(); + } + else if(value==true){ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Active : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Device Test: Callback : isDeviceActive : MIC: Active : FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_001 + * @tc.name : setAudioParameter - Promise - Character & Number + * @tc.desc : setAudioParameter - Promise - Character & Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_001', 0, async function (done) { + const promise = audioManager.setAudioParameter('PBits per sample', '8 bit'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('PBits per sample').then(async function (value){ + if(value=='8 bit'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: Bits per sample : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : Bits per sample : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_002 + * @tc.name : setAudioParameter - Promise - Number + * @tc.desc : setAudioParameter - Promise - Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_002', 0, async function (done) { + const promise = audioManager.setAudioParameter('PNumber', '4800'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('PNumber').then(async function (value){ + if(value=='4800'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PNumber : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PNumber : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_003 + * @tc.name : setAudioParameter - Promise - Long Number + * @tc.desc : setAudioParameter - Promise - Long Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_003', 0, async function (done) { + const promise = audioManager.setAudioParameter('PLNumber','28374837458743875804735081439085918459801437584738967509184509813904850914375904790589104859018439058901437587459173948590813490859018349051943076918459013489058901437509479068901458098143095890143767140938590471357140937541609749103750981094385094173950713490570914389075159079014769751875901459048095813'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('PLNumber').then(async function (value){ + if(value=='28374837458743875804735081439085918459801437584738967509184509813904850914375904790589104859018439058901437587459173948590813490859018349051943076918459013489058901437509479068901458098143095890143767140938590471357140937541609749103750981094385094173950713490570914389075159079014769751875901459048095813'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PLNumber : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PLNumber : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_004 + * @tc.name : setAudioParameter - Promise - Decimal + * @tc.desc : setAudioParameter - Promise - Decimal + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_004', 0, async function (done) { + const promise = audioManager.setAudioParameter('PDecimal', '10.000000234324324324'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('PDecimal').then(async function (value){ + if(value=='10.000000234324324324'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PDecimal : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PDecimal : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_005 + * @tc.name : setAudioParameter - Promise - Parameter name Number + * @tc.desc : setAudioParameter - Promise - Parameter name Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_005', 0, async function (done) { + const promise = audioManager.setAudioParameter('1212', 'PPNumber'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('1212').then(async function (value){ + if(value=='PPNumber'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: 1212 : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : 1212 : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_006 + * @tc.name : setAudioParameter - Promise - Special Characters + * @tc.desc : setAudioParameter - Promise - Special Characters + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_006', 0, async function (done) { + const promise = audioManager.setAudioParameter('PSpecial', '[]\:";<>?,./~!@#$%^*()_+-={}|'); + promise.then(async function (value) { + console.info('AudioFrameworkTest: Audio Parameter Test: Promise : setAudioParameter'); + audioManager.getAudioParameter('PSpecial').then(async function (value){ + if(value=='[]\:";<>?,./~!@#$%^*()_+-={}|'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PSpecial : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PSpecial : FAIL :' +value); + expect(false).assertTrue(); + } + }); + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_007 + * @tc.name : setAudioParameter - Callback - Character & Number + * @tc.desc : setAudioParameter - Callback - Character & Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_007', 0, async function (done) { + audioManager.setAudioParameter('CBSample Rate', '16 bit', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: CBSample Rate : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('CBSample Rate', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBSample Rate: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='16 bit'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBSample Rate: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBSample Rate: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_008 + * @tc.name : setAudioParameter - Callback - Special Character + * @tc.desc : setAudioParameter - Callback - Special Character + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_008', 0, async function (done) { + audioManager.setAudioParameter('Special', '~!@#$%^*()_+-={}|[]\:";<>?,./', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: Special : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('Special', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: Special: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='~!@#$%^*()_+-={}|[]\:";<>?,./'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: Special: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: Special: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_009 + * @tc.name : setAudioParameter - Callback - Decimal + * @tc.desc : setAudioParameter - Callback - Decimal + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_009', 0, async function (done) { + audioManager.setAudioParameter('CBDecimal', '10000.21321432432432', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: CBDecimal : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('CBDecimal', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBDecimal: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='10000.21321432432432'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBDecimal: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBDecimal: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_010 + * @tc.name : setAudioParameter - Callback - Number + * @tc.desc : setAudioParameter - Callback - Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_010', 0, async function (done) { + audioManager.setAudioParameter('CBNumber', '5454', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback :CBNumber : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: CBNumber : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('CBNumber', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBNumber: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='5454'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBNumber: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBNumber: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_011 + * @tc.name : setAudioParameter - Callback - Long Number + * @tc.desc : setAudioParameter - Callback - Long Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_011', 0, async function (done) { + audioManager.setAudioParameter('CBLNumber', '54549873894789327498327984328954897598235748278979823758947895238975847389578932784328974983274823897584728957234873289759832578947598392874798327598498275894728975892478953728947823748732894783927589748975837248973289748923758972489379832748927349879237589324789327589472789743892748932749832749832749879832749837298', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback :CBLNumber : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: CBLNumber : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('CBLNumber', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBLNumber: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='54549873894789327498327984328954897598235748278979823758947895238975847389578932784328974983274823897584728957234873289759832578947598392874798327598498275894728975892478953728947823748732894783927589748975837248973289748923758972489379832748927349879237589324789327589472789743892748932749832749832749879832749837298'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBLNumber: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBLNumber: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_setAudioParameter_012 + * @tc.name : setAudioParameter - Callback - Parameter name Number + * @tc.desc : setAudioParameter - Callback - Parameter name Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_setAudioParameter_012', 0, async function (done) { + audioManager.setAudioParameter('345667', 'xyza', (err, value) => { + console.info('AudioFrameworkTest: Audio Parameter Test: Callback :345667 : setAudioParameter'); + if (err) { + console.error(`AudioFrameworkTest: Callback : setAudioParameter: 345667 : Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + audioManager.getAudioParameter('345667', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: 345667: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='xyza'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: 345667: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: 345667: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_001 + * @tc.name : getAudioParameter - Promise - Character & Number + * @tc.desc : getAudioParameter - Promise - Character & Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_001', 0, async function (done) { + const promise = audioManager.getAudioParameter('PBits per sample'); + promise.then(async function (value){ + if(value=='8 bit'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: Bits per sample : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : Bits per sample : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_002 + * @tc.name : getAudioParameter - Promise - Number + * @tc.desc : getAudioParameter - Promise - Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_002', 0, async function (done) { + const promise = audioManager.getAudioParameter('PNumber'); + promise.then(async function (value){ + if(value=='4800'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PNumber : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PNumber : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_003 + * @tc.name : getAudioParameter - Promise - Long Number + * @tc.desc : getAudioParameter - Promise - Long Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_003', 0, async function (done) { + const promise = audioManager.getAudioParameter('PLNumber'); + promise.then(async function (value){ + if(value=='28374837458743875804735081439085918459801437584738967509184509813904850914375904790589104859018439058901437587459173948590813490859018349051943076918459013489058901437509479068901458098143095890143767140938590471357140937541609749103750981094385094173950713490570914389075159079014769751875901459048095813'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PLNumber : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PLNumber : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_004 + * @tc.name : getAudioParameter - Promise - Decimal + * @tc.desc : getAudioParameter - Promise - Decimal + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_004', 0, async function (done) { + const promise = audioManager.getAudioParameter('PDecimal'); + promise.then(async function (value){ + if(value=='10.000000234324324324'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PDecimal : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PDecimal : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_005 + * @tc.name : getAudioParameter - Promise - Parameter name Number + * @tc.desc : getAudioParameter - Promise - Parameter name Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_005', 0, async function (done) { + const promise = audioManager.getAudioParameter('1212'); + promise.then(async function (value){ + if(value=='PPNumber'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: 1212 : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : 1212 : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_006 + * @tc.name : getAudioParameter - Promise - Special Characters + * @tc.desc : getAudioParameter - Promise - Special Characters + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_006', 0, async function (done) { + const promise = audioManager.getAudioParameter('PSpecial'); + promise.then(async function (value){ + if(value=='[]\:";<>?,./~!@#$%^*()_+-={}|'){ + console.info('AudioFrameworkTest: Promise: getAudioParameter: PSpecial : PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Promise: getAudioParameter : PSpecial : FAIL :' +value); + expect(false).assertTrue(); + } + }); + await promise; + done(); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_007 + * @tc.name : getAudioParameter - Callback - Character & Number + * @tc.desc : getAudioParameter - Callback - Character & Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_007', 0, async function (done) { + audioManager.getAudioParameter('CBSample Rate', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBSample Rate: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='16 bit'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBSample Rate: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBSample Rate: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_008 + * @tc.name : getAudioParameter - Callback - Special Character + * @tc.desc : getAudioParameter - Callback - Special Character + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_008', 0, async function (done) { + audioManager.getAudioParameter('Special', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: Special: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='~!@#$%^*()_+-={}|[]\:";<>?,./'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: Special: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: Special: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_009 + * @tc.name : getAudioParameter - Callback - Decimal + * @tc.desc : getAudioParameter - Callback - Decimal + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_009', 0, async function (done) { + audioManager.getAudioParameter('CBDecimal', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBDecimal: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='10000.21321432432432'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBDecimal: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBDecimal: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_010 + * @tc.name : getAudioParameter - Callback - Number + * @tc.desc : getAudioParameter - Callback - Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_010', 0, async function (done) { + audioManager.getAudioParameter('CBNumber', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBNumber: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='5454'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBNumber: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBNumber: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_011 + * @tc.name : getAudioParameter - Callback - Long Number + * @tc.desc : getAudioParameter - Callback - Long Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_011', 0, async function (done) { + audioManager.getAudioParameter('CBLNumber', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: CBLNumber: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='54549873894789327498327984328954897598235748278979823758947895238975847389578932784328974983274823897584728957234873289759832578947598392874798327598498275894728975892478953728947823748732894783927589748975837248973289748923758972489379832748927349879237589324789327589472789743892748932749832749832749879832749837298'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBLNumber: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: CBLNumber: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + /* * + * @tc.number : SUB_AUDIO_MANAGER_getAudioParameter_012 + * @tc.name : getAudioParameter - Callback - Parameter name Number + * @tc.desc : getAudioParameter - Callback - Parameter name Number + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_AUDIO_MANAGER_getAudioParameter_012', 0, async function (done) { + audioManager.getAudioParameter('345667', (err, value) => { + if (err) { + console.error(`AudioFrameworkTest: Callback : getAudioParameter: 345667: Error: ${err.message}`); + expect(false).assertTrue(); + return; + } + else if(value=='xyza'){ + console.info('AudioFrameworkTest: Callback: getAudioParameter: 345667: PASS :' +value); + expect(true).assertTrue(); + } + else{ + console.info('AudioFrameworkTest: Callback: getAudioParameter: 345667: FAIL :' +value); + expect(false).assertTrue(); + } + done(); + }); + }) + + function sleep (ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + function displayDeviceProp(value, index, array) { + var devRoleName; + var devTypeName; + if (value.deviceRole==1) { + devRoleName = 'INPUT_DEVICE'; + } + else if (value.deviceRole==2) { + devRoleName = 'OUTPUT_DEVICE'; + } + else { + devRoleName = 'ERROR : UNKNOWN'; + } + + if (value.deviceType == 1) { + devTypeName = 'SPEAKER'; + } + else if (value.deviceType == 2){ + devTypeName = 'WIRED_HEADSET'; + } + else if (value.deviceType == 3){ + devTypeName = 'BLUETOOTH_SCO'; + } + else if (value.deviceType == 4){ + devTypeName = 'BLUETOOTH_A2DP'; + } + else if (value.deviceType == 5){ + devTypeName = 'MIC'; + } + else { + devTypeName = 'ERROR : UNKNOWN'; + } + + console.info(`AudioFrameworkTest: device role: ${devRoleName}`); + deviceRoleValue = value.deviceRole; + console.info(`AudioFrameworkTest: device type: ${devTypeName}`); + deviceTypeValue = value.deviceType; + + } + +}) \ No newline at end of file diff --git a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioManager.test.js b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioManager.test.js deleted file mode 100755 index 27e0fbbd718f0e6985f6c496fe6368a5474211c9..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioManager.test.js +++ /dev/null @@ -1,450 +0,0 @@ -/* - * Copyright (C) 2021 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 audio from '@ohos.multimedia.audio'; -import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' -describe('AudioManager.test.js', function () { - const audioManager = audio.getAudioManager(); - var maxVolume = 1; - var minVolume = 0; - var deviceTypeValue = null; - var deviceRoleValue = null; - - beforeAll(function () { - console.info('beforeAll: Prerequisites at the test suite level, which are executed before the test suite is executed.'); - - }) - - beforeEach(function () { - console.info('beforeEach: Prerequisites at the test case level, which are executed before each test case is executed.'); - - }) - afterEach(function () { - console.info('afterEach: Test case-level clearance conditions, which are executed after each test case is executed.'); - - }) - afterAll(function () { - console.info('afterAll: Test suite-level cleanup condition, which is executed after the test suite is executed'); - - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_SetVolume_001 - * @tc.name : Set Audiomanager with volume type media 01 - * @tc.desc : Audiomanager SetVolume media-success - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_SetVolume_001', 0, function () { - audioManager.setVolume(1, 12).then(function (data) { - console.info('Media setVolume successful promise'); - audioManager.getVolume(1).then(function (data) { - console.info('Media getVolume promise ' + data); - expect(data).assertEqual(12); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_SetVolume_001 : PASS'); - }); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_SetVolume_002 - * @tc.name : Set Audiomanager with volume type ringtone 02 - * @tc.desc : Audiomanager SetVolume media-success - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_SetVolume_002', 0, function () { - audioManager.setVolume(2, 11).then(function (data) { - console.info('Media setVolume successful promise '); - audioManager.getVolume(2).then(function (data) { - console.info('Media getVolume promise ' + data); - expect(data).assertEqual(11); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_SetVolume_002 : PASS'); - }); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_SetVolume_003 - * @tc.name : Set Audiomanager with volume type media and callback - * @tc.desc : Audiomanager SetVolume media-success - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_SetVolume_003', 0, function () { - audioManager.setVolume(1, 10, (err, value) => { - if (err) { - console.error(`failed to set volume ${err.message}`); - return; - } - console.log(`Media setVolume successful callback`); - audioManager.getVolume(1, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getVolume ${value}`); - expect(value).assertEqual(10); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_SetVolume_003 : PASS'); - }); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_SetVolume_004 - * @tc.name : Set Audiomanager with volume type ringtone and callback - * @tc.desc : Audiomanager should set the volume as per the API and return it from Get API - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_SetVolume_004', 0, function () { - audioManager.setVolume(2, 13, (err, value) => { - if (err) { - console.error(`failed to set volume ${err.message}`); - return; - } - console.log(`Media setVolume successful callback`); - audioManager.getVolume(1, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getVolume ${value}`); - expect(value).assertEqual(13); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_SetVolume_004 : PASS'); - }); - }); - }) - - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_SetVolume_005 - * @tc.name : Set Audiomanager with volume level beyond maxvolume - * @tc.desc : Audiomanager should return an error for setting the volume - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_SetVolume_005', 0, function () { - audioManager.setVolume(2, 16, (err, value) => { - if (err) { - console.error(`failed to set volume ${err.message}`); - return; - } - audioManager.getVolume(2, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getVolume ${value}`); - if (value != 16) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_SetVolume_005 : PASS'); - } - }); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_001 - * @tc.name : Check Audiomanager get max volume for media - * @tc.desc : Audiomanager get max volume - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_001', 0, function () { - audioManager.getMaxVolume(1).then(function (data) { - console.info('Media getMaxVolume promise ' + data); - expect(data).assertEqual(maxVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_001 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_002 - * @tc.name : Check Audiomanager get max volume for ringtone - * @tc.desc : Audiomanager get max volume-ringtone - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_002', 0, function () { - - audioManager.getMaxVolume(2).then(function (data) { - console.info('Media getMaxVolume promise ' + data); - expect(data).assertEqual(maxVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_002 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_003 - * @tc.name : Check Audiomanager get max volume for media with callback - * @tc.desc : Audiomanager get max volume - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_003', 0, function () { - audioManager.getMaxVolume(1, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getMaxVolume ${value}`); - expect(value).assertEqual(maxVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_003 : PASS'); - }); - }); - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_004 - * @tc.name : Check Audiomanager get max volume for ringtone with callback - * @tc.desc : Audiomanager get max volume - rigtone - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_004', 0, function () { - audioManager.getMaxVolume(2, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getMaxVolume ${value}`); - expect(value).assertEqual(maxVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMaxVolume_004 : PASS'); - }); - }); - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_001 - * @tc.name : Check Audiomanager get min volume for media - * @tc.desc : Audiomanager get min volume- media - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_001', 0, function () { - audioManager.getMinVolume(1).then(function (data) { - console.info('Media getMinVolume promise ' + data); - expect(data).assertEqual(minVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_001 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_002 - * @tc.name : Check Audiomanager get min volume for ringtone - * @tc.desc : Audiomanager get min volume-ringtone - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_002', 0, function () { - audioManager.getMinVolume(2).then(function (data) { - console.info('Media getMinVolume promise ' + data); - expect(data).assertEqual(minVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_002 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_003 - * @tc.name : Check Audiomanager get min volume for media with callback - * @tc.desc : Audiomanager get min volume- media - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_003', 0, function () { - audioManager.getMinVolume(1, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getMinVolume ${value}`); - expect(value).assertEqual(minVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_003 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_004 - * @tc.name : Check Audiomanager get min volume for ringtone - * @tc.desc : Audiomanager get min volume-ringtone - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_004', 0, function () { - audioManager.getMinVolume(2, (err, value) => { - if (err) { - console.error(`failed to get volume ${err.message}`); - return; - } - console.log(`Media getMinVolume ${value}`); - expect(value).assertEqual(minVolume); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_GetMinVolume_004 : PASS'); - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_Get_Devices_001 - * @tc.name : Check Audiomanager get devices with DEVICES_FLAG 01 - * @tc.desc : Audiomanager get device-positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_001', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(1, (err, value) => { - if (err) { - console.error(`failed to get devices ${err.message}`); - return; - } - console.log('getDevices output devices'); - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_001 : PASS'); - } - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_Get_Devices_002 - * @tc.name : Check Audiomanager get devices with DEVICES_FLAG 02 - * @tc.desc : Audiomanager get device-positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_002', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(2, (err, value) => { - if (err) { - console.error(`failed to get devices ${err.message}`); - return; - } - console.log('getDevices output devices'); - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_002 : PASS'); - } - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_Get_Devices_003 - * @tc.name : Check Audiomanager get devices with DEVICES_FLAG 03 - * @tc.desc : Audiomanager get device-positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_003', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(3, (err, value) => { - if (err) { - console.error(`failed to get devices ${err.message}`); - return; - } - console.log('getDevices All devices'); - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_003 : PASS'); - } - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetDevice_004 - * @tc.name : Check Audiomanager get devices with deviceflag value as 1 - * @tc.desc : Audiomanager get getdevices without callback - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_004', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(1).then(function (value) { - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_004 : PASS'); - } - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetDevice_005 - * @tc.name : Check Audiomanager get devices with deviceflag values as 2 - * @tc.desc : Audiomanager get getdevices without callback - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_005', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(2).then(function (value) { - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_005 : PASS'); - } - }); - }) - - /* * - * @tc.number : SUB_MEDIA_AUDIO_MANAGER_GetDevice_006 - * @tc.name : Check Audiomanager get devices with deviceflag values as 3 - * @tc.desc : Audiomanager get getdevices without callback - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_AUDIO_MANAGER_Get_Devices_006', 0, function () { - deviceRoleValue = null; - deviceTypeValue = null; - audioManager.getDevices(3).then(function (value) { - value.forEach(displayDeviceProp); - if (deviceTypeValue != null && deviceRoleValue != null) { - expect(true).assertTrue(); - console.info('testCase_SUB_MEDIA_AUDIO_MANAGER_Get Devices_006 : PASS'); - } - }); - }) - - function displayDeviceProp(value, index, array) { - console.log(`device role: ${value.deviceRole}`); - deviceRoleValue = value.deviceRole; - console.log(`device type: ${value.deviceType}`); - deviceTypeValue = value.deviceType; - } -}) \ No newline at end of file diff --git a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioPlayer.test.js b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioPlayer.test.js deleted file mode 100755 index 23c02d63a142826f6262f89e30e817a76b29b9f6..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/AudioPlayer.test.js +++ /dev/null @@ -1,719 +0,0 @@ -/* - * Copyright (c) 2021 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 media from '@ohos.multimedia.media'; -import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' -describe('AudioPlayer.test.js', function () { - var audiosourcemp3 = 'file///build/testAudio/ff-16b-2c-44100hz.mp3'; - var audiosourcewav = 'file///build/testAudio/ff-16b-2c-44100hz.wav'; - var audiosourceaac = 'file///build/testAudio/ff-16b-2c-44100hz.aac'; - var audiosourceac3 = 'file///build/testAudio/ff-16b-2c-44100hz.ac3'; - var audiosourceaiff = 'file///build/testAudio/ff-16b-2c-44100hz.aiff'; - var audiosourceflac = 'file///build/testAudio/ff-16b-2c-44100hz.flac'; - var audiosourcem4a = 'file///build/testAudio/ff-16b-2c-44100hz.m4a'; - var audiosourcemp4 = 'file///build/testAudio/ff-16b-2c-44100hz.mp4'; - var audiosourceogg = 'file///build/testAudio/ff-16b-2c-44100hz.ogg'; - var audiosourceopus = 'file///build/testAudio/ff-16b-2c-44100hz.opus'; - var audiosourcets = 'file///build/testAudio/ff-16b-2c-44100hz.ts'; - var audiosourcewma = 'file///build/testAudio/ff-16b-2c-44100hz.wma'; - var docsource = 'file///build/testAudio/asc.doc'; - var wrongsource = 'file///abd'; - var audioPlayer = media.createAudioPlayer(); - var audioState; - var waitTimer; - - beforeAll(function () { - console.info('beforeAll: Prerequisites at the test suite level, which are executed before the test suite is executed.'); - }) - - beforeEach(function () { - console.info('beforeEach: Prerequisites at the test case level, which are executed before each test case is executed.'); - }) - - afterEach(function () { - console.info('afterEach: Test case-level clearance conditions, which are executed after each test case is executed.'); - audioPlayer.release(); - }) - - afterAll(function () { - console.info('afterAll: Test suite-level cleanup condition, which is executed after the test suite is executed'); - }) - - console.info('Setting Callback'); - player.on('play', (err, action) => { - if (err) { - console.log(`err returned in play() callback`); - return; - } - console.log(`Play() callback is called`); - console.info('Current Player Status: ' + player.state); - console.info('Current Song duration: ' + player.duration); - console.log(`In play callback current time: ${player.currentTime}`); - console.info('Pause aac'); - player.pause(); - }); - - player.on('pause', (err, action) => { - if (err) { - console.log(`err returned in pause() callback`); - return; - } - console.log(`Pause() callback is called`); - }); - - player.on('stop', (err, action) => { - if (err) { - console.log(`err returned in stop() callback`); - return; - } - console.log(`Stop() callback is called`); - }); - - player.on('dataLoad', (err, action) => { - if (err) { - console.log(`err returned in dataLoad() callback`); - return; - } - console.log(`dataLoad callback is called, cuurent time: ${player.currentTime}`); - console.log(`Duration of the source: ${player.duration}`); - }); - - player.on('finish', (err, action) => { - if (err) { - console.log(`err returned in finish() callback`); - return; - } - console.log(`Player finish callback is called`); - }); - - player.on('timeUpdate', (err, action) => { - if (err) { - console.log(`err returned in timeUpdate() callback`); - return; - } - console.log(`In timeupdate callback current time: ${player.currentTime}`); - }); - - player.on('durationchange', (err, action) => { - if (err) { - console.log(`err returned in durationchange callback`); - return; - } - console.log(`Durationchange callback is called`); - }); - - player.on('error', (err, action) => { - console.error(`player error: ${err.code}`); - }); - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_001 - * @tc.name : Set Audio Play 01 - * @tc.desc : Audio Play-Positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_002 - * @tc.name : Audio play 02 - * @tc.desc : Audio play-Error return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_002', 0, function () { - audioPlayer.src = docsource; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertNotEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_003 - * @tc.name : Audio play 03 - * @tc.desc : Audio Play-Positive return value - wav - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_003', 0, function () { - audioPlayer.src = audiosourcewav; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('SUB_MEDIA_PLAYER_Play_003 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_004 - * @tc.name : Audio play 04 - * @tc.desc : Audio Play-Positive return value - acc - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_004', 0, function () { - audioPlayer.src = audiosourceaac; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_004 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_005 - * @tc.name : Audio play 05 - * @tc.desc : Audio Play-Positive return value - ac3 - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_005', 0, function () { - audioPlayer.src = audiosourceac3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_005 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_006 - * @tc.name : Audio play 06 - * @tc.desc : Audio Play-Positive return value - aiff - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_006', 0, function () { - audioPlayer.src = audiosourceaiff; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_006 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_007 - * @tc.name : Audio play 07 - * @tc.desc : Audio Play-Positive return value - m4a - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_007', 0, function () { - audioPlayer.src = audiosourcem4a; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_007 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_008 - * @tc.name : Audio play 08 - * @tc.desc : Audio Play-Positive return value - mp4 - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_008', 0, function () { - audioPlayer.src = audiosourcemp4; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_008 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_009 - * @tc.name : Audio play 09 - * @tc.desc : Audio Play-Positive return value - ogg - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_009', 0, function () { - audioPlayer.src = audiosourceogg; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_009 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_010 - * @tc.name : Audio play 10 - * @tc.desc : Audio Play-Positive return value - opus - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_010', 0, function () { - audioPlayer.src = audiosourceopus; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_010 : PASS'); - - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_011 - * @tc.name : Audio play 11 - * @tc.desc : Audio Play-Positive return value - ts - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_011', 0, function () { - audioPlayer.src = audiosourcets; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_011 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_012 - * @tc.name : Audio play 12 - * @tc.desc : Audio Play-Positive return value - wma - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_012', 0, function () { - audioPlayer.src = audiosourcewma; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_012 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Play_013 - * @tc.name : Audio play 13 - * @tc.desc : Audio Play-Positive return value - flac - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Play_013', 0, function () { - audioPlayer.src = audiosourceflac; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Play_013 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Pause_001 - * @tc.name : Audio Pause 01 - * @tc.desc : Audio Pause-Positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Pause_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.pause(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('paused'); - console.info('testCase_SUB_MEDIA_PLAYER_Pause_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Pause_002 - * @tc.name : Audio Pause 02 - * @tc.desc : Audio Pause-Error return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Pause_002', 0, function () { - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('stopped'); - audioPlayer.pause(); - audioState = audioPlayer.state; - expect(audioState).assertNotEqual('paused'); - console.info('testCase_SUB_MEDIA_PLAYER_Pause_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Stop_001 - * @tc.name : Audio Stop 01 - * @tc.desc : Audio Stop-Positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Stop_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('stopped'); - console.info('testCase_SUB_MEDIA_PLAYER_Stop_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Stop_002 - * @tc.name : Audio Stop 02 - * @tc.desc : Audio Stop-Error return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Stop_002', 0, function () { - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertNotEqual('stopped'); - console.info('testCase_SUB_MEDIA_PLAYER_Stop_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Seek_001 - * @tc.name : Audio Seek 01 - * @tc.desc : Audio Seek-Positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Seek_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - var timeUs = 10; - audioPlayer.seek(timeUs); - var getCurrentTime = audioPlayer.currenTime; - if (getCurrentTime >= seekTime) { - console.info("current position after seek : " + getCurrentTime); - console.info('testCase_SUB_MEDIA_PLAYER_Seek_001 : PASS'); - } - else - console.info('Error'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Seek_002 - * @tc.name : Audio Seek 02 - * @tc.desc : Audio Seek-error return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Seek_002', 0, function () { - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('stopped'); - audioPlayer.seek(10); - var getCurrentTime = audioPlayer.currenTime; - expect(getCurrentTime).assertNotEqual(10); - console.info('testCase_SUB_MEDIA_PLAYER_Seek_002 : PASS'); - - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Seek_003 - * @tc.name : Audio Seek 03 - * @tc.desc : Audio Seek-Negative return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Seek_003', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - setTimeout(waitTimer, 2); - expect(audioState).assertEqual('playing'); - audioPlayer.seek(-10); - var getCurrentTime = audioPlayer.currenTime; - expect(getCurrentTime).assertNotEqual(-10); - console.info('testCase_SUB_MEDIA_PLAYER_Seek_003 : PASS'); - - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Seek_004 - * @tc.name : Audio Seek 04 - * @tc.desc : Audio Seek-out of range for the media its playing - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Seek_004', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.seek(16000); - var getCurrentTime = audioPlayer.currenTime; - expect(getCurrentTime).assertNotEqual(16000); - console.info('testCase_SUB_MEDIA_PLAYER_Seek_004 : PASS'); - - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_Playback_status_001 - * @tc.name : Audio Playback status 01 - * @tc.desc : Audio Playback status-positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_Playback_status_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - setTimeout(waitTimer, 2); - expect(audioState).assertEqual('playing'); - console.info('testCase_SUB_MEDIA_PLAYER_Playback_status_001 : PASS'); - - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_EnableLooping_001 - * @tc.name : Audio EnableLooping 01 - * @tc.desc : Audio Enable Looping after play - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_EnableLooping_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.loop = true; - expect(audioPlayer.loop).assertEqual(true); - console.info('testCase_SUB_MEDIA_PLAYER_EnableLooping_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_EnableLooping_002 - * @tc.name : Audio EnableLooping 02 - * @tc.desc : Audio EnableLooping- Enable Loop before play - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_EnableLooping_002', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.loop = true; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - expect(audioPlayer.loop).assertEqual(true); - console.info('testCase_SUB_MEDIA_PLAYER_EnableLooping_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_EnableLooping_003 - * @tc.name : Audio EnableLooping 03 - * @tc.desc : Audio EnableLooping-Disable Loop - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_EnableLooping_003', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.loop = true; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.loop = false; - expect(audioPlayer.loop).assertEqual(false); - console.info('testCase_SUB_MEDIA_PLAYER_EnableLooping_003 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_SetVolume_001 - * @tc.name : Audio SetVolume 01 - * @tc.desc : Audio SetVolume-Positive return value - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_SetVolume_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.volume = 0.5; - expect(audioPlayer.volume).assertEqual(0.5); - console.info('testCase_SUB_MEDIA_PLAYER_SetVolume_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_SetVolume_002 - * @tc.name : Audio SetVolume 02 - * @tc.desc : Audio SetVolume-Mute - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_SetVolume_002', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.volume = 0; - expect(setVolume).assertEqual(audioPlayer.volume); - console.info('testCase_SUB_MEDIA_PLAYER_SetVolume_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_SetVolume_003 - * @tc.name : Audio SetVolume 03 - * @tc.desc : Audio SetVolume-Max - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_SetVolume_003', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - setTimeout(waitTimer, 2); - expect(audioState).assertEqual('playing'); - audioPlayer.volume = 1; - expect(audioPlayer.volume).assertEqual(1); - console.info('testCase_SUB_MEDIA_PLAYER_SetVolume_003 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_SetVolume_004 - * @tc.name : Audio SetVolume 04 - * @tc.desc : Audio SetVolume-Out of range - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_SetVolume_004', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('playing'); - audioPlayer.volume = 2; - expect(audioPlayer.volume).assertNotEqual(2); - console.info('testCase_SUB_MEDIA_PLAYER_SetVolume_004 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_SetVolume_005 - * @tc.name : Audio SetVolume 05 - * @tc.desc : Audio SetVolume-negative range - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_SetVolume_005', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - audioPlayer.volume = -1; - expect(audioPlayer.volume).assertNotEqual(-1); - console.info('testCase_SUB_MEDIA_PLAYER_SetVolume_005 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_GetCurrentTime_001 - * @tc.name : Audio GetCurrentTime 01 - * @tc.desc : Audio GetCurrentTime-Play and get current time - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_GetCurrentTime_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - setTimeout(waitTimer, 20); - expect(audioState).assertEqual('playing'); - var getCurrentTime = audioPlayer.currentTime; - expect(getCurrentTime).assertEqual(20); - console.info('testCase_SUB_MEDIA_PLAYER_GetCurrentTime_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_GetCurrentTime_002 - * @tc.name : Audio GetCurrentTime 02 - * @tc.desc : Audio GetCurrentTime- Error, get current time when nothing is playing. - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_GetCurrentTime_002', 0, function () { - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('stopped'); - var getCurrentTime = audioPlayer.currentTime; - expect(getCurrentTime).assertNotEqual(0); - console.info('testCase_SUB_MEDIA_PLAYER_GetCurrentTime_002 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_GetDuration_001 - * @tc.name : Audio GetDuration 01 - * @tc.desc : Audio GetDuration-Play and get duration. - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_GetDuration_001', 0, function () { - audioPlayer.src = audiosourcemp3; - audioPlayer.play(); - audioState = audioPlayer.state; - setTimeout(waitTimer, 2); - expect(audioState).assertEqual('playing'); - var getDuration = audioPlayer.duration; - expect(getDuration).assertEqual(200); - console.info('testCase_SUB_MEDIA_PLAYER_GetDuration_001 : PASS'); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_GetDuration_002 - * @tc.name : Audio GetDuration 02 - * @tc.desc : Audio GetDuration- Error, get duration time when nothing is playing. - * @tc.size : MEDIUM - * @tc.type : Function - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_GetDuration_002', 0, function () { - audioPlayer.stop(); - audioState = audioPlayer.state; - expect(audioState).assertEqual('stopped'); - var getDuration = audioPlayer.duration; - expect(getDuration).assertNotEqual(0); - console.info('testCase_SUB_MEDIA_PLAYER_GetDuration_002 : PASS'); - }) -}) \ No newline at end of file diff --git a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/List.test.js b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/List.test.js index 08238ae1053836d4439d138937162358b0949890..3231cc2f49dfaea82409d5b2b93f1f967953aa57 100644 --- a/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/List.test.js +++ b/multimedia/audio/audio_js_standard/audioManager/project/entry/src/main/js/test/List.test.js @@ -13,4 +13,4 @@ * limitations under the License. */ -require('./AudioManager.test.js') \ No newline at end of file +require('./AudioFramework.test.js') \ No newline at end of file diff --git a/multimedia/audio/audio_js_standard/audioPlayer/hap/AudioPlayer_JS.hap b/multimedia/audio/audio_js_standard/audioPlayer/hap/AudioPlayer_JS.hap index 4d204d275043026c0b56c6394db8ce3ec3274f85..52a7090d320b575685ed80e3fce135032d5edac3 100644 Binary files a/multimedia/audio/audio_js_standard/audioPlayer/hap/AudioPlayer_JS.hap and b/multimedia/audio/audio_js_standard/audioPlayer/hap/AudioPlayer_JS.hap differ diff --git a/multimedia/audio/audio_js_standard/audioPlayer/hap/entry-debug-rich-signed.hap b/multimedia/audio/audio_js_standard/audioPlayer/hap/entry-debug-rich-signed.hap deleted file mode 100755 index 9f875f974f29fc7ad6da92d74e451a1dd7c33eb3..0000000000000000000000000000000000000000 Binary files a/multimedia/audio/audio_js_standard/audioPlayer/hap/entry-debug-rich-signed.hap and /dev/null differ diff --git a/multimedia/audio/audio_js_standard/audioPlayer/project/entry/src/main/js/test/PlayerLocalTestAudioFUNC.test.js b/multimedia/audio/audio_js_standard/audioPlayer/project/entry/src/main/js/test/PlayerLocalTestAudioFUNC.test.js index e9249f0fc26b11bf7bc3827db877898bbcfd02cc..5a37ba3117ddf21bd736dfd3f86d6eab665b8e3a 100644 --- a/multimedia/audio/audio_js_standard/audioPlayer/project/entry/src/main/js/test/PlayerLocalTestAudioFUNC.test.js +++ b/multimedia/audio/audio_js_standard/audioPlayer/project/entry/src/main/js/test/PlayerLocalTestAudioFUNC.test.js @@ -16,13 +16,10 @@ import media from '@ohos.multimedia.media' import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' -describe('PlayerLocalTestAudioFUNC', function () { +describe('PlayerLocalTestAudioAPI', function () { var audioPlayer = media.createAudioPlayer(); var audioSource = "data/media/audio/Homey.mp3"; var PLAY_TIME = 3000; - var DURATION_TIME = 89239; - var SEEK_TIME = 5000; - var DELTA_TIME = 1000; var ENDSTATE = 0; var SRCSTATE = 1; var PLAYSTATE = 2; @@ -35,11 +32,12 @@ describe('PlayerLocalTestAudioFUNC', function () { var ERRORSTATE = 9; var FINISHSTATE = 10; var LOOPSTATE = 11; - var NOERROR = 0; - var STEPERRCODE = 38; - var SEEKERROR = 'seekError'; + var DURATION_TIME = 89239; + var SEEK_TIME = 5000; + var DELTA_TIME = 1000; var PAUSEERROR = 'pauseError'; - var errCode = NOERROR; + var PLAYERROR = 'playError'; + var loopValue = false; beforeAll(function () { console.log("beforeAll case"); }) @@ -50,6 +48,7 @@ describe('PlayerLocalTestAudioFUNC', function () { afterEach(function () { console.log("afterEach case"); + audioPlayer.release(); }) afterAll(function () { @@ -57,7 +56,7 @@ describe('PlayerLocalTestAudioFUNC', function () { }) var sleep = function(time) { - for(var t = Date.now(); Date.now() - t <= time;); + for(var t = Date.now();Date.now() - t <= time;); }; var initAudioPlayer = function() { @@ -66,6 +65,9 @@ describe('PlayerLocalTestAudioFUNC', function () { var nextStep = function(mySteps, done) { if (mySteps[0] == ENDSTATE) { + if (mySteps[1] == false || mySteps[1] == true) { + expect(audioPlayer.loop).assertEqual(mySteps[1]); + } done(); return; } @@ -102,11 +104,13 @@ describe('PlayerLocalTestAudioFUNC', function () { console.log(`case to release`); mySteps.shift(); audioPlayer.release(); + nextStep(mySteps, done); break; case LOOPSTATE: - audioPlayer.loop = mySteps[1]; + loopValue = mySteps[1]; mySteps.shift(); mySteps.shift(); + audioPlayer.loop = loopValue; nextStep(mySteps, done); break; default: @@ -134,7 +138,6 @@ describe('PlayerLocalTestAudioFUNC', function () { return; } expect(audioPlayer.state).assertEqual('playing'); - sleep(PLAY_TIME); nextStep(mySteps, done); }); @@ -205,455 +208,247 @@ describe('PlayerLocalTestAudioFUNC', function () { console.log(`case error called,errName is ${err.name}`); console.log(`case error called,errCode is ${err.code}`); console.log(`case error called,errMessage is ${err.message}`); - expect(err.code).assertEqual(errCode); if ((mySteps[0] == SEEKSTATE) || (mySteps[0] == VOLUMESTATE)) { expect(mySteps[2]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[3]); mySteps.shift(); mySteps.shift(); mySteps.shift(); mySteps.shift(); + nextStep(mySteps, done); + } else if (mySteps[0] == ERRORSTATE) { + mySteps.shift(); + mySteps.shift(); + } else if (mySteps[0] == ENDSTATE) { + console.log('case release player error'); } else { expect(mySteps[1]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[2]); mySteps.shift(); mySteps.shift(); mySteps.shift(); + nextStep(mySteps, done); } - nextStep(mySteps, done); }); }; /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0100 - * @tc.name : 001.本地音频初始状态：进行播放 - * @tc.desc : 1.播放成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0200 - * @tc.name : 002.本地音频播放状态：进行暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0300 - * @tc.name : 003.本地音频暂停状态：进行恢复播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0500 - * @tc.name : 005.本地音频播放状态：进行结束播放 - * @tc.desc : 1.播放成功 - 2.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0600 - * @tc.name : 006.本地音频播放状态：暂停后恢复播放，再次暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Pause成功 - 5.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0600', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0700 - * @tc.name : 007.本地音频暂停状态：暂停后结束播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0800 - * @tc.name : 008.本地音频播放状态：暂停后恢复播放，再结束播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.播放成功 - 4.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0900 - * @tc.name : 009.本地音频播放状态：停止播放后重新开始播放，暂停后恢复播放，再结束播放 - * @tc.desc : 1.播放成功 - 2.Stop成功 -　　　　　　　　　　　　　　　　3.播放成功 -　　　　　　　　　　　　　　　　4.Pause成功 -　　　　　　　　　　　　　　　　5.Play成功 -　　　　　　　　　　　　　　　　6.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, - PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1000 - * @tc.name : 010.本地音频暂停状态：停止播放后重新开始播放，暂停后结束播放 - * @tc.desc : 1.播放成功 -　　　　　　　　　　　　　　　　2.Pause成功 -　　　　　　　　　　　　　　　　3.Stop成功 -　　　　　　　　　　　　　　　　4.播放成功 -　　　　　　　　　　　　　　　　5.Pause成功 -　　　　　　　　　　　　　　　　6.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200 + * @tc.name : 02.play操作在pause之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, - PAUSESTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1100 - * @tc.name : 011.本地音频播放状态：停止播放后重新开始播放，再次结束播放 - * @tc.desc : 1.播放成功 - 　　　　　　　　　　　　　 2.Stop成功 - 　　　　　　　　　　　　　 3.播放成功 - 　　　　　　　　　　　　　 4.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0300 + * @tc.name : 03.play操作在stop之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0300', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1200 - * @tc.name : 012.本地音频暂停状态：暂停后再次play - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.播放成功 - 4.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0400 + * @tc.name : 04.play操作在seek之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0400', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, SEEK_TIME, PLAYSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1300 - * @tc.name : 013.本地音频停止状态：停止播放后暂停 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Pause失败 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0800 + * @tc.name : 08.play操作在reset之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1300', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0800', 0, async function (done) { + var mySteps = new Array(SRCSTATE, RESETSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1400 - * @tc.name : 014.本地音频初始状态：开始播放，进行Seek，再暂停 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Pause成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0900 + * @tc.name : 09.play操作在release之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, 0, PAUSESTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0900', 0, async function (done) { + var mySteps = new Array(SRCSTATE, RELEASESTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1500 - * @tc.name : 015.本地音频初始状态：开始播放，暂停后进行Seek，再恢复播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 - 4.Play成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0100 + * @tc.name : 01.pause操作在createAudioPlayer之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, SEEKSTATE, DURATION_TIME / 2, - SEEKSTATE, audioPlayer.duration, PLAYSTATE, FINISHSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0100', 0, async function (done) { + var mySteps = new Array(PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); - audioPlayer.src = audioSource; + audioPlayer.pause(); }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1600 - * @tc.name : 016.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek，再暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Seek成功 - 5.pause成功 - 6.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0200 + * @tc.name : 02.pause操作在play之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1600', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, PAUSESTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1700 - * @tc.name : 017.本地音频初始状态：开始播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0300 + * @tc.name : 02.pause操作在stop之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 2, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0300', 0, async function (done) { + var mySteps = new Array(PLAYSTATE, STOPSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1800 - * @tc.name : 018.本地音频初始状态：开始播放，进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Stop成功 - 4.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0400 + * @tc.name : 04.pause操作在seek之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 2, - STOPSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0400', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, PAUSESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1900 - * @tc.name : 019.本地音频初始状态：开始播放，停止播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1900', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, 0, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2000 - * @tc.name : 020.本地音频初始状态：开始播放，暂停后进行Seek - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0200 + * @tc.name : 02.stop操作在play之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2100 - * @tc.name : 021.本地音频初始状态：开始播放，暂停后进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 - 4.Stop成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0300 + * @tc.name : 03.stop操作在pause之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME / 2, - STOPSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0300', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2200 - * @tc.name : 022.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Seek成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0400 + * @tc.name : 04.stop操作在seek之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0400', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, STOPSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2300 - * @tc.name : 023.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Stop成功 - 5.Seek成功 - 6.Stop成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0200 + * @tc.name : 02.seek操作在play之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, STOPSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2400 - * @tc.name : 024.本地音频初始状态：开始播放，停止播放，进行Seek，重新播放 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - 4.重新播放成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0300 + * @tc.name : 03.seek操作在pause之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2400', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, 0, ERRORSTATE, SEEKERROR, - RESETSTATE, SRCSTATE, PLAYSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0300', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, SEEK_TIME, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2500 - * @tc.name : 025.本地音频播放状态：进行Seek，Seek到文件开始的位置 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0900 + * @tc.name : 9.seek到起始位置(0) + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2500', 0, async function (done) { + it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0900', 0, async function (done) { var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, 0, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -661,227 +456,145 @@ describe('PlayerLocalTestAudioFUNC', function () { }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2600 - * @tc.name : 026.本地音频初始状态：开始播放，停止播放，进行Seek,再暂停 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - 4.Pause失败 - 5.Reset成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0200 + * @tc.name : 02.reset操作在play之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2600', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, - SEEKERROR, PAUSESTATE, ERRORSTATE, PAUSEERROR, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2700 - * @tc.name : 027.本地音频初始状态：开始播放，停止播放，进行Seek，再进行恢复播放操作 - * @tc.desc : 1.播放成功； - 2.Stop成功； - 3.Seek失败 - 4.恢复播放成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0300 + * @tc.name : 03.reset操作在pause之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2700', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, - SEEKERROR, RESETSTATE, SRCSTATE, PLAYSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0300', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RESETSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2800 - * @tc.name : 028.本地音频播放状态：进行Seek，Seek到文件结尾的位置 - * @tc.desc : 1.播放成功 - 2.Seek成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0200 + * @tc.name : 02.release操作在play之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME, FINISHSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0200', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2900 - * @tc.name : 029.本地音频播放状态：进行Seek，Seek到超过文件结尾的位置 - * @tc.desc : 1.播放成功 - 2.Seek到结尾 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0300 + * @tc.name : 03.release操作在pause之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, - FINISHSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0300', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RELEASESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3000 - * @tc.name : 030.本地音频播放状态：进行Seek，Seek到文件随机的位置 - * @tc.desc : 1.Seek成功，查看currenTime与seek到的位置一致 - 2.当前位置为seek设置的随机位置 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0400 + * @tc.name : 04.release操作在stop之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 5, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0400', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RELEASESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3200 - * @tc.name : 032.本地音频播放状态：暂停时Seek到文件开始，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0500 + * @tc.name : 05.release操作在seek之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, PLAYSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0500', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, RELEASESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3300 - * @tc.name : 033.本地音频播放状态：暂停时Seek到文件结尾，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0700 + * @tc.name : 07.release操作在reset之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME, PLAYSTATE, - FINISHSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0700', 0, async function (done) { + var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, RELEASESTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); audioPlayer.src = audioSource; }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3400 - * @tc.name : 034.本地音频播放状态：暂停时Seek到超过文件结尾的位置，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0100 + * @tc.name : 01.获取参数操作在createAudioPlayer之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, PLAYSTATE, - FINISHSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0100', 0, async function (done) { initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; + expect(audioPlayer.src).assertEqual(undefined); + expect(audioPlayer.duration).assertEqual(undefined); + expect(audioPlayer.currentTime).assertEqual(undefined); + expect(audioPlayer.state).assertEqual('idle'); + expect(audioPlayer.loop).assertEqual(false); + done(); }) /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3500 - * @tc.name : 035.本地音频播放状态：播放时Seek到超过文件结尾的位置，再重新开始播放 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.finish回调函数触发，并重新开始播放 - 3.Play成功 + * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0200 + * @tc.name : 02.获取参数操作在setsrc之后 + * @tc.desc : * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 + * @tc.type : API Test + * @tc.level : Level 2 */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, - FINISHSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); + it('SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0200', 0, async function (done) { initAudioPlayer(); - setCallback(mySteps, done); audioPlayer.src = audioSource; + sleep(PLAY_TIME); + expect(audioPlayer.src).assertEqual(audioSource); + expect(audioPlayer.currentTime).assertEqual(0); + expect(audioPlayer.duration).assertEqual(DURATION_TIME); + expect(audioPlayer.state).assertEqual('paused'); + expect(audioPlayer.loop).assertEqual(false); + done(); }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3600 - * @tc.name : 036.支持设置循环播放 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3600', 0, async function (done) { - var playCount = 0; - var seekCount = 0; - var testAudioPlayer = media.createAudioPlayer(); - testAudioPlayer.on('dataLoad', () => { - console.log(`case dataLoad called`); - expect(testAudioPlayer.currentTime).assertEqual(0); - expect(testAudioPlayer.duration).assertEqual(DURATION_TIME); - expect(testAudioPlayer.state).assertEqual('paused'); - testAudioPlayer.loop = true; - testAudioPlayer.play(); - }); - testAudioPlayer.on('play', () => { - console.log(`case play called`); - console.log(`case play currentTime is ${testAudioPlayer.currentTime}`); - expect(testAudioPlayer.duration).assertEqual(DURATION_TIME); - expect(testAudioPlayer.state).assertEqual('playing'); - sleep(PLAY_TIME); - if (playCount == 1) { - return; - } - playCount++ - testAudioPlayer.seek(DURATION_TIME); - }); - testAudioPlayer.on('timeUpdate', (seekDoneTime) => { - if (typeof (seekDoneTime) == "undefined") { - console.log(`case seek filed,errcode is ${seekDoneTime}`); - return; - } - if (seekCount == 1) { - testAudioPlayer.reset(); - return; - } - seekCount++ - console.log(`case seekDoneTime is ${seekDoneTime}`); - console.log(`case seek called`); - expect(testAudioPlayer.currentTime + 1).assertClose(seekDoneTime + 1, DELTA_TIME); - }); - testAudioPlayer.on('finish', () => { - expect(testAudioPlayer.state).assertEqual('playing'); - console.log(`case finish called`); - }); - testAudioPlayer.on('reset', () => { - expect(testAudioPlayer.state).assertEqual('idle'); - console.log(`case reset called`); - testAudioPlayer.release(); - done(); - }); - testAudioPlayer.src = audioSource; - }) - -}) \ No newline at end of file +}) diff --git a/multimedia/audio/audio_js_standard/audioPlayer_API/hap/AudioPlayer_Api_JS.hap b/multimedia/audio/audio_js_standard/audioPlayer_API/hap/AudioPlayer_Api_JS.hap index 370140caddca20a5e480daa6b1e030f7b2ed44c1..d5c09ef9a547c4c31a4ed9317719c9f722582175 100644 Binary files a/multimedia/audio/audio_js_standard/audioPlayer_API/hap/AudioPlayer_Api_JS.hap and b/multimedia/audio/audio_js_standard/audioPlayer_API/hap/AudioPlayer_Api_JS.hap differ diff --git a/multimedia/audio/audio_js_standard/audioPlayer_API/project/entry/src/main/js/test/PlayerLocalTestAudioAPI.test.js b/multimedia/audio/audio_js_standard/audioPlayer_API/project/entry/src/main/js/test/PlayerLocalTestAudioAPI.test.js index 477555dae4aa0e2a1e821ec2669f9bc8a14ee9e6..5a37ba3117ddf21bd736dfd3f86d6eab665b8e3a 100644 --- a/multimedia/audio/audio_js_standard/audioPlayer_API/project/entry/src/main/js/test/PlayerLocalTestAudioAPI.test.js +++ b/multimedia/audio/audio_js_standard/audioPlayer_API/project/entry/src/main/js/test/PlayerLocalTestAudioAPI.test.js @@ -32,34 +32,27 @@ describe('PlayerLocalTestAudioAPI', function () { var ERRORSTATE = 9; var FINISHSTATE = 10; var LOOPSTATE = 11; - var NOERROR = 0; var DURATION_TIME = 89239; var SEEK_TIME = 5000; - var VOLUMEVALUE = 0.1; var DELTA_TIME = 1000; - var SRCERROR = 'sourceError'; - var SEEKERROR = 'seekError'; var PAUSEERROR = 'pauseError'; var PLAYERROR = 'playError'; - var STOPERROR = 'stopError'; - var errCode = NOERROR; - var ERRSTEP = 38; - var ERRSRC = 22; + var loopValue = false; beforeAll(function () { - console.info("beforeAll case"); + console.log("beforeAll case"); }) beforeEach(function () { - console.info("beforeEach case"); + console.log("beforeEach case"); }) afterEach(function () { - console.info("afterEach case"); - errCode = NOERROR; + console.log("afterEach case"); + audioPlayer.release(); }) afterAll(function () { - console.info("afterAll case"); + console.log("afterAll case"); }) var sleep = function(time) { @@ -67,7 +60,6 @@ describe('PlayerLocalTestAudioAPI', function () { }; var initAudioPlayer = function() { - audioPlayer.release(); audioPlayer = media.createAudioPlayer(); } @@ -81,43 +73,44 @@ describe('PlayerLocalTestAudioAPI', function () { } switch (mySteps[0]) { case SRCSTATE: - console.info(`case to prepare`); + console.log(`case to prepare`); audioPlayer.src = audioSource; break; case PLAYSTATE: - console.info(`case to play`); + console.log(`case to play`); audioPlayer.play(); break; case PAUSESTATE: - console.info(`case to pause`); + console.log(`case to pause`); audioPlayer.pause(); break; case STOPSTATE: - console.info(`case to stop`); + console.log(`case to stop`); audioPlayer.stop(); break; case RESETSTATE: - console.info(`case to reset`); + console.log(`case to reset`); audioPlayer.reset(); break; case SEEKSTATE: - console.info(`case seek to time is ${mySteps[1]}`); + console.log(`case seek to time is ${mySteps[1]}`); audioPlayer.seek(mySteps[1]); break; case VOLUMESTATE: - console.info(`case to setVolume`); + console.log(`case to setVolume`); audioPlayer.setVolume(mySteps[1]); break; case RELEASESTATE: - console.info(`case to release`); + console.log(`case to release`); mySteps.shift(); audioPlayer.release(); nextStep(mySteps, done); break; case LOOPSTATE: - audioPlayer.loop = mySteps[1]; + loopValue = mySteps[1]; mySteps.shift(); mySteps.shift(); + audioPlayer.loop = loopValue; nextStep(mySteps, done); break; default: @@ -125,10 +118,10 @@ describe('PlayerLocalTestAudioAPI', function () { } } var setCallback = function(mySteps, done) { - console.info(`case setCallback`); + console.log(`case setCallback`); audioPlayer.on('dataLoad', () => { mySteps.shift(); - console.info(`case dataLoad called`); + console.log(`case dataLoad called`); expect(audioPlayer.currentTime).assertEqual(0); expect(audioPlayer.duration).assertEqual(DURATION_TIME); expect(audioPlayer.state).assertEqual('paused'); @@ -137,11 +130,11 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.on('play', () => { mySteps.shift(); - console.info(`case play called`); - console.info(`case play currentTime is ${audioPlayer.currentTime}`); + console.log(`case play called`); + console.log(`case play currentTime is ${audioPlayer.currentTime}`); expect(audioPlayer.duration).assertEqual(DURATION_TIME); if (mySteps[0] == FINISHSTATE) { - console.info(`case wait for finish`); + console.log(`case wait for finish`); return; } expect(audioPlayer.state).assertEqual('playing'); @@ -150,8 +143,8 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.on('pause', () => { mySteps.shift(); - console.info(`case pause called`); - console.info(`case pause currentTime is ${audioPlayer.currentTime}`); + console.log(`case pause called`); + console.log(`case pause currentTime is ${audioPlayer.currentTime}`); expect(audioPlayer.duration).assertEqual(DURATION_TIME); expect(audioPlayer.state).assertEqual('paused'); nextStep(mySteps, done); @@ -159,14 +152,14 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.on('reset', () => { mySteps.shift(); - console.info(`case reset called`); + console.log(`case reset called`); expect(audioPlayer.state).assertEqual('idle'); nextStep(mySteps, done); }); audioPlayer.on('stop', () => { mySteps.shift(); - console.info(`case stop called`); + console.log(`case stop called`); expect(audioPlayer.currentTime).assertEqual(0); expect(audioPlayer.duration).assertEqual(DURATION_TIME); expect(audioPlayer.state).assertEqual('stopped'); @@ -175,17 +168,17 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.on('timeUpdate', (seekDoneTime) => { if (typeof (seekDoneTime) == "undefined") { - console.info(`case seek filed,errcode is ${seekDoneTime}`); + console.log(`case seek filed,errcode is ${seekDoneTime}`); return; } mySteps.shift(); mySteps.shift(); - console.info(`case seekDoneTime is ${seekDoneTime}`); - console.info(`case seek called`); + console.log(`case seekDoneTime is ${seekDoneTime}`); + console.log(`case seek called`); expect(audioPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME); - console.info(`case loop is ${audioPlayer.loop}`); + console.log(`case loop is ${audioPlayer.loop}`); if ((audioPlayer.loop == true) && (seekDoneTime == DURATION_TIME)) { - console.info('case loop is true'); + console.log('case loop is true'); sleep(PLAYSTATE); } if (seekDoneTime < audioPlayer.duration || audioPlayer.state == "paused") { @@ -194,7 +187,7 @@ describe('PlayerLocalTestAudioAPI', function () { }); audioPlayer.on('volumeChange', () => { - console.info(`case setvolume called`); + console.log(`case setvolume called`); mySteps.shift(); mySteps.shift(); if (audioPlayer.state == "playing") { @@ -207,63 +200,36 @@ describe('PlayerLocalTestAudioAPI', function () { mySteps.shift(); expect(audioPlayer.state).assertEqual('stopped'); expect(audioPlayer.currentTime).assertClose(audioPlayer.duration, DELTA_TIME); - console.info(`case finish called`); + console.log(`case finish called`); nextStep(mySteps, done); }); audioPlayer.on('error', (err) => { - console.info(`case error called,errName is ${err.name}`); - console.info(`case error called,errCode is ${err.code}`); - console.info(`case error called,errMessage is ${err.message}`); - expect(err.code).assertEqual(errCode); + console.log(`case error called,errName is ${err.name}`); + console.log(`case error called,errCode is ${err.code}`); + console.log(`case error called,errMessage is ${err.message}`); if ((mySteps[0] == SEEKSTATE) || (mySteps[0] == VOLUMESTATE)) { expect(mySteps[2]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[3]); mySteps.shift(); mySteps.shift(); mySteps.shift(); mySteps.shift(); + nextStep(mySteps, done); + } else if (mySteps[0] == ERRORSTATE) { + mySteps.shift(); + mySteps.shift(); + } else if (mySteps[0] == ENDSTATE) { + console.log('case release player error'); } else { expect(mySteps[1]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[2]); mySteps.shift(); mySteps.shift(); mySteps.shift(); + nextStep(mySteps, done); } - nextStep(mySteps, done); }); }; - /* * - * @tc.number : SUB_MEDIA_PLAYER_createAudioPlayer_API_0100 - * @tc.name : 01.创建一个音频播放器createAudioPlayer() - * @tc.desc : testcreateAudioPlayer - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_createAudioPlayer_API_0100', 0, async function (done) { - var audioPlayerTest = media.createAudioPlayer(); - expect(audioPlayerTest != null).assertTrue(); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0100 - * @tc.name : 01.play操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.play(); - }) - /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200 * @tc.name : 02.play操作在pause之后 @@ -273,7 +239,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -289,7 +254,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0300', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -320,7 +284,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0800', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(SRCSTATE, RESETSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -336,7 +299,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0900', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(SRCSTATE, RELEASESTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -352,7 +314,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0100', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -383,7 +344,6 @@ describe('PlayerLocalTestAudioAPI', function () { * @tc.level : Level 2 */ it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0300', 0, async function (done) { - errCode = ERRSTEP; var mySteps = new Array(PLAYSTATE, STOPSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); initAudioPlayer(); setCallback(mySteps, done); @@ -405,53 +365,6 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0800 - * @tc.name : 08.pause操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0800', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RESETSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900 - * @tc.name : 09.pause操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RELEASESTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0100 - * @tc.name : 01.stop操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.stop(); - }) /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0200 @@ -498,55 +411,6 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0800 - * @tc.name : 08.stop操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0800', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900 - * @tc.name : 09.stop操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0900', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0100 - * @tc.name : 01.seek操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SEEKSTATE, SEEK_TIME, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - var seekTime = SEEK_TIME; - audioPlayer.seek(seekTime); - }) - /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0200 * @tc.name : 02.seek操作在play之后 @@ -576,53 +440,6 @@ describe('PlayerLocalTestAudioAPI', function () { setCallback(mySteps, done); audioPlayer.src = audioSource; }) - - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0500 - * @tc.name : 05.seek操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0500', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0700 - * @tc.name : 07.seek操作调用3次 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, SEEKSTATE, 6000, SEEKSTATE, 7000, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0800 - * @tc.name : 08.seek到码流任意某一点(0~码流时长) - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0800', 0, async function (done) { - var randomTime = parseInt(Math.random()*(audioPlayer.duration + 1),10); - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, randomTime, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0900 * @tc.name : 9.seek到起始位置(0) @@ -637,69 +454,6 @@ describe('PlayerLocalTestAudioAPI', function () { setCallback(mySteps, done); audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1000 - * @tc.name : 10.seek到结束位置(码流时长) - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1100 - * @tc.name : 11.seek操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, SEEKSTATE, SEEK_TIME, - ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1200 - * @tc.name : 12.seek操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1200', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, SEEKSTATE, SEEK_TIME, - ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1400 - * @tc.name : 14.seek到超出码流时长 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DURATION_TIME, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0200 @@ -731,52 +485,6 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0400 - * @tc.name : 04.reset操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0500 - * @tc.name : 05.reset操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0100 - * @tc.name : 01.release操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0100', 0, async function (done) { - var mySteps = new Array(RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.release(); - done(); - }) - /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0200 * @tc.name : 02.release操作在play之后 @@ -852,237 +560,6 @@ describe('PlayerLocalTestAudioAPI', function () { audioPlayer.src = audioSource; }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0300 - * @tc.name : 003.播放文件名超长（255）的本地音频素材 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = "data/media/audio/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.mp3"; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0500 - * @tc.name : 005.播放文件名为“” - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0500', 0, async function (done) { - errCode = ERRSRC; - var mySteps = new Array(SRCSTATE, ERRORSTATE, SRCERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = ""; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0800 - * @tc.name : 008. 传入的地址不存在 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0800', 0, async function (done) { - errCode = 331350552; - var mySteps = new Array(SRCSTATE, ERRORSTATE, SRCERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = "data/media/audio/no.mp3"; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0100 - * @tc.name : 01.set loop true操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0100', 0, async function (done) { - initAudioPlayer(); - audioPlayer.loop = true; - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0200 - * @tc.name : 02.set loop true操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0300 - * @tc.name : 03.set loop true操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0400 - * @tc.name : 04.set loop true操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0500 - * @tc.name : 05.set loop true操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0700 - * @tc.name : 07.set loop true操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, LOOPSTATE, true, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0800 - * @tc.name : 08.set loop false操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0800', 0, async function (done) { - initAudioPlayer(); - audioPlayer.loop = false; - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0900 - * @tc.name : 09.set loop false操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1000 - * @tc.name : 10.set loop false操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1100 - * @tc.name : 11.set loop false操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1200 - * @tc.name : 12.set loop false操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1400 - * @tc.name : 14.set loop false操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0100 * @tc.name : 01.获取参数操作在createAudioPlayer之后 @@ -1120,5 +597,4 @@ describe('PlayerLocalTestAudioAPI', function () { expect(audioPlayer.loop).assertEqual(false); done(); }) - }) diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/BUILD.gn b/multimedia/audio/audio_native_standard/media_cpp_test_standard/BUILD.gn deleted file mode 100644 index dc4e9709ccc700c2cfa50c47a86702c381e28ef4..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/BUILD.gn +++ /dev/null @@ -1,70 +0,0 @@ -# Copyright (C) 2021 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("//test/xts/tools/build/suite.gni") -module_output_path = "hit/ActsMediaCppStandardTest" - -############################################################################### -config("media_cpp_config") { - visibility = [ ":*" ] - include_dirs = [ - "include", - "//multimedia/media_standard/frameworks/innerkitsimpl/native/player/include", - ] -} - -ohos_moduletest_suite("ActsMediaCppStandardTest") { - module_out_path = module_output_path - sources = [ - "recorder/src/fuction/ActsVideoRecorderTest.cpp", - "recorder/src/fuction/ActsAudioRecoederTest.cpp", - "player/Testplayer.cpp", - "player/src/function/ActsPlayerFuncTest.cpp", - "player/src/function/ActsPlayerFuncAsyncTest.cpp", - "player/src/function/ActsPlayerStateTest.cpp", - "player/src/function/ActsPlayerStateAsyncTest.cpp", - "player/src/api/01.SetSource.cpp", - "player/src/api/02.Prepare.cpp", - "player/src/api/03.Play.cpp", - "player/src/api/04.Pause.cpp", - "player/src/api/05.Stop.cpp", - "player/src/api/06.Reset.cpp", - "player/src/api/07.Seek.cpp", - "player/src/api/08.SetVolume.cpp", - "player/src/api/09.SetLooping.cpp", - "player/src/api/10.SetPlaybackSpeed.cpp", - "player/src/api/11.PrepareAsync.cpp", - "player/src/api/12.GetCurrentTime.cpp", - ] - include_dirs = [ - "include", - "player/include", - "recorder/include", - "//base/startup/syspara_lite/interfaces/innerkits/native/syspara/include", - ] - cflags = [ - "-Wall" - ] - cflags_cc = cflags - deps = [ - "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", - "//foundation/graphic/standard:libwms_client", - "//third_party/googletest:gtest_main", - "//base/startup/syspara_lite/interfaces/innerkits/native/syspara:syspara", - ] - external_deps = [ - "ipc:ipc_core", - "multimedia_media_standard:media_client", - ] - configs = [ ":media_cpp_config" ] -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/Test.json b/multimedia/audio/audio_native_standard/media_cpp_test_standard/Test.json deleted file mode 100644 index f2e652539c924538878034075b1a24e5bacf074a..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/Test.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "kits": [ - { - "push": [ - "ActsMediaCppStandardTest->/data/local/tmp/ActsMediaCppStandardTest" - ], - "type": "PushKit", - "post-push": [ - "chmod -R 777 /data/local/tmp/*" - ] - } - ], - "driver": { - "native-test-timeout": "120000", - "type": "CppTest", - "module-name": "ActsMediaCppStandardTest", - "runtime-hint": "1s", - "native-test-device-path": "/data/local/tmp" - }, - "description": "Configuration for ActsMediaCppStandardTest Tests" -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/include/mediatest_log.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/include/mediatest_log.h deleted file mode 100644 index 6fbf44067eb9903debabae33a59e524638bdd2af..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/include/mediatest_log.h +++ /dev/null @@ -1,51 +0,0 @@ - -/* - * Copyright (C) 2021 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. - */ -#include "media_log.h" - -#define MEDIA_DEBUG_LOG(fmt, ...) \ -do { \ - printf(fmt, ##__VA_ARGS__); \ - printf("\n"); \ - __MEDIA_LOG(::OHOS::HiviewDFX::HiLog::Debug, fmt, ##__VA_ARGS__); \ -} while (0) \ - -#define MEDIA_INFO_LOG(fmt, ...) \ -do { \ - printf(fmt, ##__VA_ARGS__); \ - printf("\n"); \ - __MEDIA_LOG(::OHOS::HiviewDFX::HiLog::Info, fmt, ##__VA_ARGS__); \ -} while (0) \ - -#define MEDIA_ERROR_LOG(fmt, ...) \ -do { \ - printf(fmt, ##__VA_ARGS__); \ - printf("\n"); \ - __MEDIA_LOG(::OHOS::HiviewDFX::HiLog::Error, fmt, ##__VA_ARGS__); \ -} while (0) \ - -namespace { - constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "MediaTest"}; -} - -namespace MediaTest { - constexpr int SURFACE_QUEUE_SIZE = 5; - const float VOLUME = 0.5f; - const int FIRST_ARG_IDX = 1; - const int SECOND_ARG_IDX = 2; - const int THIRD_ARG = 3; - const int HEIGHT = 720; - const int WIDTH = 1280; -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/Testplayer.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/Testplayer.cpp deleted file mode 100644 index 51f2301ee10db5a067784f95edfc535404e23461..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/Testplayer.cpp +++ /dev/null @@ -1,384 +0,0 @@ - -/* - * Copyright (C) 2021 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. - */ - -#include "Testplayer.h" -#include "parameter.h" - -using namespace OHOS; -using namespace OHOS::Media; -using namespace PlayerNameSpace; - -namespace PlayerNameSpace { -std::string GetUri() -{ - char path[256] = "/data/1.mp4"; - GetParameter("sys.media.test.stream.path", "/data/1.mp4", &path[0], 256); - MEDIA_INFO_LOG("PATH : %s", path); - return path; -} -} -TestPlayer::TestPlayer(PlayerSignal *test) - : test_(test) -{ -} -TestPlayer::~TestPlayer() -{ -} -bool TestPlayer::CreatePlayer() -{ - player = PlayerFactory::CreatePlayer(); - if (player == nullptr) { - return false; - } - return true; -} -int32_t TestPlayer::SetSource(const std::string &uri) -{ - return player->SetSource(uri); -} - -int32_t TestPlayer::Play() -{ - int32_t ret = player->Play(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_STARTED) { - std::unique_lock lockPlay(test_->mutexPlay_); - test_->condVarPlay_.wait_for(lockPlay, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_STARTED) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::Prepare() -{ - int32_t ret = player->Prepare(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_PREPARED) { - std::unique_lock lockPrepare(test_->mutexPrepare_); - test_->condVarPrepare_.wait_for(lockPrepare, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_PREPARED) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::PrepareAsync() -{ - int32_t ret = player->PrepareAsync(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_PREPARED) { - std::unique_lock lockPrepare(test_->mutexPrepare_); - test_->condVarPrepare_.wait_for(lockPrepare, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_PREPARED) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::Pause() -{ - int32_t ret = player->Pause(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_PAUSED) { - std::unique_lock lockPause(test_->mutexPause_); - test_->condVarPause_.wait_for(lockPause, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_PAUSED) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::Stop() -{ - int32_t ret = player->Stop(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_STOPPED) { - std::unique_lock lockStop(test_->mutexStop_); - test_->condVarStop_.wait_for(lockStop, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_STOPPED) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::Reset() -{ - int32_t ret = player->Reset(); - if (test_->mutexFlag_ == true && test_->state_ != PLAYER_IDLE) { - std::unique_lock lockReset(test_->mutexReset_); - test_->condVarReset_.wait_for(lockReset, std::chrono::seconds(WAITSECOND)); - if (test_->state_ != PLAYER_IDLE) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::Release() -{ - return player->Release(); -} - -int32_t TestPlayer::SetVolume(float leftVolume, float rightVolume) -{ - return player->SetVolume(leftVolume, rightVolume); -} - -int32_t TestPlayer::Seek(int32_t mseconds, PlayerSeekMode mode) -{ - test_->seekDoneFlag_ = false; - test_->seekPositon_ = mseconds; - int32_t ret = player->Seek(mseconds, mode); - if (test_->mutexFlag_ == true && test_->seekDoneFlag_ == false) { - std::unique_lock lockSeek(test_->mutexSeek_); - test_->condVarSeek_.wait_for(lockSeek, std::chrono::seconds(WAITSECOND)); - if (test_->seekDoneFlag_ != true) { - return -1; - } - } - return ret; -} - -int32_t TestPlayer::GetCurrentTime(int32_t ¤tTime) -{ - return player->GetCurrentTime(currentTime); -} - -int32_t TestPlayer::GetDuration(int32_t &duration) -{ - return player->GetDuration(duration); -} - -int32_t TestPlayer::SetPlaybackSpeed(PlaybackRateMode mode) -{ - return player->SetPlaybackSpeed(mode); -} - -int32_t TestPlayer::GetPlaybackSpeed(PlaybackRateMode &mode) -{ - return player->GetPlaybackSpeed(mode); -} -sptr TestPlayer::GetVideoSurface(WindowConfig sub_config) -{ - char surface[256] = "null"; - GetParameter("sys.media.test.surface", "null", &surface[0], 256); - mwindow = WindowManager::GetInstance()->CreateWindow(&g_config); - if (mwindow == nullptr) { - MEDIA_ERROR_LOG("Create mwindow failed!!!"); - return nullptr; - } - sptr videoSurface = nullptr; - if (strcmp(surface, "null") == 0) { - return videoSurface; - } - if (strcmp(surface, "subwindow") == 0) { - InitSubWindow(sub_config); - videoSurface = window->GetSurface(); - } else if (strcmp(surface, "window") == 0) { - videoSurface = mwindow->GetSurface(); - videoSurface->SetUserData(SURFACE_FORMAT, std::to_string(PIXEL_FMT_RGBA_8888)); - std::string format = videoSurface->GetUserData(SURFACE_FORMAT); - MEDIA_INFO_LOG("SetUserData SURFACE_FORMAT = %s", format.c_str()); - } - return videoSurface; -} -int32_t TestPlayer::SetVideoSurface(const sptr surface) -{ - char parameter[256] = "null"; - GetParameter("sys.media.test.surface", "null", ¶meter[0], 256); - if (strcmp(parameter, "null") == 0) { - MEDIA_INFO_LOG("sys.media.test.surface null"); - return 0; - } - return player->SetVideoSurface(surface); -} - -bool TestPlayer::IsPlaying() -{ - return player->IsPlaying(); -} - -bool TestPlayer::IsLooping() -{ - return player->IsLooping(); -} - -int32_t TestPlayer::SetLooping(bool loop) -{ - return player->SetLooping(loop); -} - -int32_t TestPlayer::SetPlayerCallback(const std::shared_ptr &callback) -{ - return player->SetPlayerCallback(callback); -} - -void TestPlayer::InitSubWindow(WindowConfig sub_config) -{ - sptr buffer; - BufferRequestConfig requestConfig; - int32_t releaseFence; - mwindow->GetRequestConfig(requestConfig); - (void)mwindow->GetSurface()->RequestBuffer(buffer, releaseFence, requestConfig); - uint32_t buffSize = buffer->GetSize(); - void *bufferVirAddr = buffer->GetVirAddr(); - (void)memset_s(bufferVirAddr, buffSize, 0, buffSize); - BufferFlushConfig flushConfig = { - .damage = { - .x = 0, - .y = 0, - .w = requestConfig.width, - .h = requestConfig.height, - }, - .timestamp = 0, - }; - if (mwindow->GetSurface()->FlushBuffer(buffer, -1, flushConfig) != 0) { - MEDIA_ERROR_LOG("FlushBuffer failed"); - } - window = WindowManager::GetInstance()->CreateSubWindow(mwindow->GetWindowID(), &sub_config); - ASSERT_NE(nullptr, window); - if (window == nullptr) { - MEDIA_ERROR_LOG("Create window failed!!!"); - return; - } - return; -} - -TestPlayerCallback::TestPlayerCallback(PlayerSignal *test) - : test_(test) -{ -} -TestPlayerCallback::~TestPlayerCallback() -{ -} -void TestPlayerCallback::OnError(PlayerErrorType errorType, int32_t errorCode) -{ - errorNum++; - errorType_ = errorType; - errorCode_ = errorCode; - MEDIA_INFO_LOG("TestPlayerCallback: OnError errorType is %d, errorCode is %d", errorType_, errorCode_); -} -void TestPlayerCallback::OnInfo(PlayerOnInfoType type, int32_t extra, const Format &InfoBody) -{ - switch (type) { - case INFO_TYPE_SEEKDONE: - seekDoneFlag = true; - test_->SetSeekResult(true); - MEDIA_INFO_LOG("TestPlayerCallback: OnSeekDone currentPositon is %d", extra); - if (abs(test_->seekPositon_ - extra) <= DELTA_TIME) { - test_->condVarSeek_.notify_all(); - } else { - test_->SetSeekResult(false); - } - break; - case INFO_TYPE_EOS: - MEDIA_INFO_LOG("TestPlayerCallback: OnEndOfStream isLooping is %d", extra); - break; - case INFO_TYPE_STATE_CHANGE: - state_ = static_cast(extra); - test_->SetState(state_); - PrintState(state_); - break; - case INFO_TYPE_POSITION_UPDATE: - postion_ = extra; - break; - case INFO_TYPE_MESSAGE: - MEDIA_INFO_LOG("TestPlayerCallback: OnMessage type is %d", extra); - break; - default: - break; - } -} - -int TestPlayerCallback::WaitForSeekDone(int32_t currentPositon) -{ - int64_t waitTime = 0; - seekDoneFlag = false; - while (seekDoneFlag != true && waitTime < WAITSECOND * 1000) { - usleep(1000); - waitTime += 1; - } - seekDoneFlag = false; - if (waitTime >= WAITSECOND * 1000) { - MEDIA_INFO_LOG("Failed to seek [%d]s ", currentPositon); - return -1; - } - return 0; -} - -int TestPlayerCallback::WaitForState(PlayerStates state) -{ - int64_t waitTime = 0; - while (state_ != state && waitTime < WAITSECOND * 1000) { - usleep(1000); - waitTime += 1; - } - if (waitTime >= WAITSECOND * 1000) { - MEDIA_INFO_LOG("Failed to wait for state[%d] down", state); - return -1; - } - return 0; -} -void TestPlayerCallback::PrintState(PlayerStates state) -{ - switch (state) { - case PLAYER_STATE_ERROR: - MEDIA_INFO_LOG("State: Error"); - break; - case PLAYER_IDLE: - MEDIA_INFO_LOG("State: IDLE"); - test_->condVarReset_.notify_all(); - break; - case PLAYER_INITIALIZED: - MEDIA_INFO_LOG("State: Initialized"); - break; - case PLAYER_PREPARING: - MEDIA_INFO_LOG("State: Preparing"); - break; - case PLAYER_PREPARED: - MEDIA_INFO_LOG("State: Prepared"); - test_->condVarPrepare_.notify_all(); - break; - case PLAYER_STARTED: - MEDIA_INFO_LOG("State: Started"); - test_->condVarPlay_.notify_all(); - break; - case PLAYER_PAUSED: - MEDIA_INFO_LOG("State: Paused"); - test_->condVarPause_.notify_all(); - break; - case PLAYER_STOPPED: - MEDIA_INFO_LOG("State: Stopped"); - test_->condVarStop_.notify_all(); - break; - case PLAYER_PLAYBACK_COMPLETE: - MEDIA_INFO_LOG("State: Complete"); - break; - default: - MEDIA_INFO_LOG("Invalid state"); - break; - } -} - -void PlayerSignal::SetState(PlayerStates state) -{ - state_ = state; -} -void PlayerSignal::SetSeekResult(bool seekDoneFlag) -{ - seekDoneFlag_ = seekDoneFlag; -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerAPITest.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerAPITest.h deleted file mode 100644 index 0757235bb3c2c7e86731923f881285bf4a752045..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerAPITest.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#ifndef PLAYER_API_TEST_H -#define PLAYER_API_TEST_H - -#include "Testplayer.h" - -namespace OHOS { -namespace Media { -class ActsPlayerAPITest : public testing::Test { -public: - // SetUpTestCase: before all testcasee - static void SetUpTestCase(void) - { - MEDIA_INFO_LOG("ActsPlayerAPITest::SetUpTestCase"); - }; - // TearDownTestCase: after all testcase - static void TearDownTestCase(void) - { - MEDIA_INFO_LOG("ActsPlayerAPITest::TearDownTestCase"); - }; - // SetUp - void SetUp(void) - { - MEDIA_INFO_LOG("ActsPlayerAPITest::SetUp"); - }; - // TearDown - void TearDown(void) - { - MEDIA_INFO_LOG("ActsPlayerAPITest::TearDown"); - }; - void LocalPlayFunc(const std::string uri, bool isAsync, WindowConfig config = g_config); -}; -} -} -#endif diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerFuncTest.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerFuncTest.h deleted file mode 100644 index 58b453f624fdcf627a9383cb1deb61ed622d6bb4..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/ActsPlayerFuncTest.h +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#ifndef PLAYER_FUNC_TEST_H -#define PLAYER_FUNC_TEST_H - -#include "Testplayer.h" - -namespace OHOS { -namespace Media { -class ActsPlayerFuncTest : public testing::Test { -public: - // SetUpTestCase: before all testcasee - static void SetUpTestCase(void) - { - MEDIA_INFO_LOG("ActsPlayerFuncTest::SetUpTestCase"); - }; - // TearDownTestCase: after all testcase - static void TearDownTestCase(void) - { - MEDIA_INFO_LOG("ActsPlayerFuncTest::TearDownTestCase"); - }; - // SetUp - void SetUp(void) - { - MEDIA_INFO_LOG("ActsPlayerFuncTest::SetUp"); - }; - // TearDown - void TearDown(void) - { - MEDIA_INFO_LOG("ActsPlayerFuncTest::TearDown"); - }; - static void LocalPlayFunc(const std::string uri, bool isAsync, WindowConfig config = g_sub_config); - static void *LocalMulitPlayFunc(void *threadarg); -}; -} -} -#endif diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/Testplayer.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/Testplayer.h deleted file mode 100644 index 4017d54bcf3aa06f6532fee0c5a081d98447a3b0..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/Testplayer.h +++ /dev/null @@ -1,134 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "securec.h" -#include "common.h" -#include "player.h" -#include "mediatest_log.h" -#include "window_manager.h" -#include "surface_type.h" -#include "display_type.h" - -namespace PlayerNameSpace { - static const int MAX_THREADS = 16; - static const int32_t PLAYING_TIME = 3; - static const int32_t PAUSED_TIME = 1; - static const int32_t SEEK_TIME_5_SEC = 5000; - static const int32_t SEEK_TIME_2_SEC = 2000; - static const int DELTA_TIME = 1000; - static const int WAITSECOND = 2; - static const int MAXTIME = 20; - static const int RET_OK = 0; - static const int32_t FILE_BEGIN = 0; - std::string GetUri(); -} - -namespace OHOS { -namespace Media { -static const std::string SURFACE_STRIDE_ALIGNMENT = "SURFACE_STRIDE_ALIGNMENT"; -static const std::string SURFACE_FORMAT = "SURFACE_FORMAT"; -static WindowConfig g_config = { - 1920, - 1080, - PIXEL_FMT_RGBA_8888, - 0, - 0, - WINDOW_TYPE_NORMAL -}; -static WindowConfig g_sub_config = { - 720, - 480, - PIXEL_FMT_YCRCB_420_SP, - 0, - 0, - WINDOW_TYPE_VIDEO, -}; - -class PlayerSignal { -public: - PlayerStates state_ = PLAYER_IDLE; - int32_t seekPositon_; - bool seekDoneFlag_; - bool mutexFlag_ = true; - std::mutex mutexSeek_; - std::mutex mutexReset_; - std::mutex mutexPrepare_; - std::mutex mutexPlay_; - std::mutex mutexPause_; - std::mutex mutexStop_; - std::condition_variable condVarSeek_; - std::condition_variable condVarReset_; - std::condition_variable condVarPrepare_; - std::condition_variable condVarPlay_; - std::condition_variable condVarPause_; - std::condition_variable condVarStop_; - - void SetState(PlayerStates state); - void SetSeekResult(bool seekDoneFlag); -}; -class TestPlayer { -public: - std::shared_ptr player; - std::unique_ptr mwindow; - std::unique_ptr window; - explicit TestPlayer(PlayerSignal *test); - ~TestPlayer(); - bool CreatePlayer(); - int32_t SetSource(const std::string &uri); - int32_t Play(); - int32_t Prepare(); - int32_t PrepareAsync(); - int32_t Pause(); - int32_t Stop(); - int32_t Reset(); - int32_t Release(); - int32_t SetVolume(float leftVolume, float rightVolume); - int32_t Seek(int32_t mseconds, PlayerSeekMode mode); - int32_t GetCurrentTime(int32_t ¤tTime); - int32_t GetDuration(int32_t &duration); - int32_t SetPlaybackSpeed(PlaybackRateMode mode); - int32_t GetPlaybackSpeed(PlaybackRateMode &mode); - sptr GetVideoSurface(WindowConfig g_sub_config); - int32_t SetVideoSurface(sptr surface); - bool IsPlaying(); - bool IsLooping(); - int32_t SetLooping(bool loop); - int32_t SetPlayerCallback(const std::shared_ptr &callback); -private: - void InitSubWindow(WindowConfig sub_config); - - PlayerSignal *test_; -}; -class TestPlayerCallback : public PlayerCallback { -public: - int errorNum = 0; - PlayerStates state_ = PLAYER_STATE_ERROR; - explicit TestPlayerCallback(PlayerSignal *test); - ~TestPlayerCallback(); - void OnError(PlayerErrorType errorType, int32_t errorCode); - int WaitForSeekDone(int32_t currentPositon); - void OnInfo(PlayerOnInfoType type, int32_t extra, const Format &InfoBody = {}); - int WaitForState(PlayerStates state); -private: - PlayerErrorType errorType_ = PLAYER_ERROR_UNKNOWN; - int32_t errorCode_ = -1; - bool seekDoneFlag = false; - int32_t postion_ = 0; - void PrintState(PlayerStates state); - - PlayerSignal *test_; -}; -} -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/common.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/common.h deleted file mode 100644 index a3655b3e1aff98ccad39e1857c47200a88a1a00b..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/include/common.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "gtest/gtest.h" - -#define MOUNT_147 "/data/147" -#define MOUNT_189 "/data/189" - diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/01.SetSource.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/01.SetSource.cpp deleted file mode 100644 index bf316c67928618958f5c275743e44659b22ba9d2..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/01.SetSource.cpp +++ /dev/null @@ -1,333 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0100 - * @tc.name : 01.SetSource操作在new之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0200 - * @tc.name : 02.SetSource操作在PrepareAsync之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0300 - * @tc.name : 03.SetSource操作在Prepare之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0400 - * @tc.name : 04.SetSource操作在Play之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0500 - * @tc.name : 05.SetSource操作在Pause之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0600 - * @tc.name : 06.SetSource操作在Seek之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0700 - * @tc.name : 07.SetSource操作在Stop之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0800 - * @tc.name : 08.SetSource操作在Reset之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_0900 - * @tc.name : 09.SetSource操作在SetVideoSurface之后 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - EXPECT_NE(RET_OK, player->SetSource(uri)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_1000 - * @tc.name : 10.SetSource操作调用3次 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetSource_1100 - * @tc.name : 11.SetSource操作在每个可进行的操作后都调用一次 - * @tc.desc : test SetSource -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetSource_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->SetSource(uri)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, player->Reset()); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/02.Prepare.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/02.Prepare.cpp deleted file mode 100644 index 4401f6894ed8932ac68e42677253b8c3bf9cd93e..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/02.Prepare.cpp +++ /dev/null @@ -1,351 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0100 - * @tc.name : 01.Prepare操作在new之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->Prepare()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0200 - * @tc.name : 02.Prepare操作在PrepareAsync之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0300 - * @tc.name : 03.Prepare操作在SetSource之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - player->SetVideoSurface(videoSurface); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0400 - * @tc.name : 04.Prepare操作在Play之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0500 - * @tc.name : 05.Prepare操作在Pause之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0600 - * @tc.name : 06.Prepare操作在Seek之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0700 - * @tc.name : 07.Prepare操作在Stop之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0800 - * @tc.name : 08.Prepare操作在Reset之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_0900 - * @tc.name : 09.Prepare操作在SetVideoSurface之后 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_1000 - * @tc.name : 10.Prepare操作调用3次 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Prepare_1100 - * @tc.name : 11.Prepare操作在每个可进行的操作后都调用一次 - * @tc.desc : test Prepare -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Prepare_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/03.Play.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/03.Play.cpp deleted file mode 100644 index 72616a595edea990e06f37555262a3677fd103e8..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/03.Play.cpp +++ /dev/null @@ -1,375 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0100 - * @tc.name : 01.Play操作在new之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->Prepare()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0200 - * @tc.name : 02.Play操作在PrepareAsync之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0300 - * @tc.name : 03.Play操作在Prepare之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0400 - * @tc.name : 03.Play操作在SetSource之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - int32_t time; - EXPECT_NE(RET_OK, player->Play()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(2000, time); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0500 - * @tc.name : 05.Play操作在Pause之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0600 - * @tc.name : 06.Play操作在Seek之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0700 - * @tc.name : 07.Play操作在Stop之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Play()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0800 - * @tc.name : 08.Play操作在Reset之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_0900 - * @tc.name : 09.Play操作在SetVideoSurface之后 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - EXPECT_NE(RET_OK, player->Play()); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_1000 - * @tc.name : 10.Play操作调用3次 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Play_1100 - * @tc.name : 11.Play操作在每个可进行的操作后都调用一次 - * @tc.desc : test Play -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Play_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/04.Pause.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/04.Pause.cpp deleted file mode 100644 index 4ac788bda8837549897e1775823da33503e9970b..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/04.Pause.cpp +++ /dev/null @@ -1,319 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0100 - * @tc.name : 01.Pause操作在new之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->Pause()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0200 - * @tc.name : 02.Pause操作在PrepareAsync之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0300 - * @tc.name : 03.Pause操作在Prepare之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0500 - * @tc.name : 05.Pause操作在Play之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0600 - * @tc.name : 06.Pause操作在Seek之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0700 - * @tc.name : 07.Pause操作在Stop之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0800 - * @tc.name : 08.Pause操作在Reset之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_0900 - * @tc.name : 09.Pause操作在SetVideoSurface之后 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_1000 - * @tc.name : 10.Pause操作调用3次 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Pause_1100 - * @tc.name : 10.Pause操作在每个可进行的操作后都调用一次 - * @tc.desc : test Pause -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Pause_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->Pause()); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->Pause()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/05.Stop.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/05.Stop.cpp deleted file mode 100644 index bc618006b84d5f3c6c0645faea366d4f293731bb..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/05.Stop.cpp +++ /dev/null @@ -1,300 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0100 - * @tc.name : 01.Stop操作在new之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->Stop()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0200 - * @tc.name : 02.Stop操作在PrepareAsync之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0300 - * @tc.name : 03.Stop操作在Prepare之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0400 - * @tc.name : 04.Stop操作在Play之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0500 - * @tc.name : 05.Stop操作在Pause之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0600 - * @tc.name : 06.Stop操作在Seek之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0800 - * @tc.name : 08.Stop操作在Reset之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_0900 - * @tc.name : 09.Stop操作在SetVideoSurface之后 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_1000 - * @tc.name : 10.Stop操作调用3次 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Stop_1100 - * @tc.name : 11.Stop操作在每个可进行的操作后都调用一次 - * @tc.desc : test Stop -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Stop_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->Stop()); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_NE(RET_OK, player->Play()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/06.Reset.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/06.Reset.cpp deleted file mode 100644 index eb8ac59f8e70c01efe2369145285ea9efb90d0fc..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/06.Reset.cpp +++ /dev/null @@ -1,248 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0100 - * @tc.name : 01.Reset操作在new之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_EQ(RET_OK, player->Reset()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0200 - * @tc.name : 02.Reset操作在PrepareAsync之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0300 - * @tc.name : 03.Reset操作在Prepare之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Reset()); - - ASSERT_EQ(RET_OK, player->SetSource(uri)); - videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0400 - * @tc.name : 04.Reset操作在Play之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0500 - * @tc.name : 05.Reset操作在Pause之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0600 - * @tc.name : 06.Reset操作在Seek之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0700 - * @tc.name : 07.Reset操作在Stop之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_0900 - * @tc.name : 09.Reset操作在SetVideoSurface之后 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Reset_1000 - * @tc.name : 10.Reset操作调用3次 - * @tc.desc : test Reset -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Reset_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/07.Seek.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/07.Seek.cpp deleted file mode 100644 index 1a2468b4b455878d65626e9d3690912035ed58d4..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/07.Seek.cpp +++ /dev/null @@ -1,568 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0100 - * @tc.name : 01.Seek操作在new之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0200 - * @tc.name : 02.Seek操作在PrepareAsync之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0300 - * @tc.name : 03.Seek操作在Prepare之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0400 - * @tc.name : 04.Seek操作在Play之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0500 - * @tc.name : 05.Seek操作在Stop之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0600 - * @tc.name : 06.Seek操作在Pause之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0800 - * @tc.name : 08.Seek操作在Reset之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_0900 - * @tc.name : 09.Seek操作在SetVideoSurface之后 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1000 - * @tc.name : 10.Seek操作调用3次 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1100 - * @tc.name : 11.seek到码流任意某一点(0~码流时长) - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - time = duration * 2 / 3; - EXPECT_EQ(RET_OK, player->Seek(time, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(duration * 2 / 3, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1200 - * @tc.name : 12.seek到起始位置(0) - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Seek(FILE_BEGIN, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1300 - * @tc.name : 13.seek到结束位置(码流时长),播放 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(RET_OK, player->Seek(duration, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(duration, time); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1325 - * @tc.name : 13.seek到结束位置(码流时长),暂停 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1325, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(RET_OK, player->Seek(duration, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(duration, time); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1350 - * @tc.name : 13.seek到结束位置(码流时长),再seek随机位置播放, - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1350, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(RET_OK, player->Seek(duration, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(duration, time); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1375 - * @tc.name : 13.seek到结束位置(码流时长),再seek随机位置暂停 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1375, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(RET_OK, player->Seek(duration, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(duration, time); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1400 - * @tc.name : 14.seek不存在的时间点 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(-1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(RET_OK, player->Seek(duration + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(duration, time); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1500 - * @tc.name : 15.seek操作在每个可进行的操作后都调用一次 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_Seek_1500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/08.SetVolume.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/08.SetVolume.cpp deleted file mode 100644 index 847d69adf113cab353fc0147622a7bb370e075d6..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/08.SetVolume.cpp +++ /dev/null @@ -1,87 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetVolume_0100 - * @tc.name : 01.SetVolume 0 0 - * @tc.desc : test SetVolume -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetVolume_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->SetVolume(0, 0)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetVolume_0200 - * @tc.name : 02.SetVolume 1.0 1.0 - * @tc.desc : test SetVolume -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetVolume_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->SetVolume(1.0, 1.0)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/09.SetLooping.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/09.SetLooping.cpp deleted file mode 100644 index 46f368f1523c8f79e9fc28fdb9b52d47a650f126..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/09.SetLooping.cpp +++ /dev/null @@ -1,447 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0100 - * @tc.name : 01.set loop true操作在createAudioPlayer之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->SetLooping(true)); - EXPECT_FALSE(player->IsLooping()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0200 - * @tc.name : 02.set loop true操作在play之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0300 - * @tc.name : 03.set loop true操作在pause之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0400 - * @tc.name : 04.set loop true操作在stop之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0500 - * @tc.name : 05.set loop true操作在seek之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0600 - * @tc.name : 06.set loop true操作在set loop true之后的每个可进行的操作后都调用一次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0700 - * @tc.name : 07.set loop true操作调用3次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0800 - * @tc.name : 08.set loop false操作在play之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_0900 - * @tc.name : 09.set loop false操作在pause之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_1000 - * @tc.name : 010.set loop false操作在stop之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_1100 - * @tc.name : 011.set loop false操作在seek之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_1200 - * @tc.name : 012.set loop false操作在set loop false之后的每个可进行的操作后都调用一次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_1200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->SetLooping(false)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetLooping_1300 - * @tc.name : 013.set loop false操作调用3次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetLooping_1300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/10.SetPlaybackSpeed.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/10.SetPlaybackSpeed.cpp deleted file mode 100644 index 79658fa8be5bd6479636c78a3c6ce4d727f5d643..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/10.SetPlaybackSpeed.cpp +++ /dev/null @@ -1,380 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0100 - * @tc.name : 01.SetPlaybackSpeed操作在createAudioPlayer之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - PlaybackRateMode mode; - EXPECT_NE(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_NE(RET_OK, player->GetPlaybackSpeed(mode)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0200 - * @tc.name : 02.SetPlaybackSpeed操作在play之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - PlaybackRateMode mode; - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0300 - * @tc.name : 03.SetPlaybackSpeed操作在pause之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - PlaybackRateMode mode; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0400 - * @tc.name : 04.SetPlaybackSpeed操作在stop之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - PlaybackRateMode mode; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0500 - * @tc.name : 05.SetPlaybackSpeed操作在seek之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - PlaybackRateMode mode; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0600 - * @tc.name : 06.SetPlaybackSpeed操作在SetPlaybackSpeed之后的每个可进行的操作后都调用一次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - PlaybackRateMode mode; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_NE(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0700 - * @tc.name : 07.SetPlaybackSpeed操作调用3次 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - PlaybackRateMode mode; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_1_25_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_1_25_X, mode); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_1_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_1_75_X, mode); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_2_00_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_2_00_X, mode); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0800 - * @tc.name : 08.SetPlaybackSpeed操作在Prepare之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - PlaybackRateMode mode; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0900 - * @tc.name : 08.SetPlaybackSpeed操作在PrepareAsync之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - PlaybackRateMode mode; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1000 - * @tc.name : 10.SetPlaybackSpeed操作在SetSource之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - PlaybackRateMode mode; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_NE(RET_OK, player->GetPlaybackSpeed(mode)); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1100 - * @tc.name : 10.SetPlaybackSpeed操作在PLAYER_PLAYBACK_COMPLETE之后 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - PlaybackRateMode mode; - int32_t durationTime; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1200 - * @tc.name : 10.SetPlaybackSpeed操作在PLAYER_PLAYBACK_COMPLETE之后,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_SetPlaybackSpeed_1200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - PlaybackRateMode mode; - int32_t durationTime; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->SetPlaybackSpeed(SPEED_FORWARD_0_75_X)); - EXPECT_EQ(RET_OK, player->GetPlaybackSpeed(mode)); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); - sleep(PLAYING_TIME); - EXPECT_EQ(SPEED_FORWARD_0_75_X, mode); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/11.PrepareAsync.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/11.PrepareAsync.cpp deleted file mode 100644 index 28634362503ab57788f713b2d3c865d78995688f..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/11.PrepareAsync.cpp +++ /dev/null @@ -1,352 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0100 - * @tc.name : 01.PrepareAsync操作在new之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0100, Reliability | SmallTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - EXPECT_NE(RET_OK, player->PrepareAsync()); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0200 - * @tc.name : 02.PrepareAsync操作在PrepareAsync之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0200, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0300 - * @tc.name : 03.PrepareAsync操作在SetSource之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0300, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_NE(RET_OK, player->SetVideoSurface(videoSurface)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0400 - * @tc.name : 04.PrepareAsync操作在Play之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0400, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0500 - * @tc.name : 05.PrepareAsync操作在Pause之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0500, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0600 - * @tc.name : 06.PrepareAsync操作在Seek之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0600, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0700 - * @tc.name : 07.PrepareAsync操作在Stop之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0700, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0800 - * @tc.name : 08.PrepareAsync操作在Reset之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0800, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_0900 - * @tc.name : 09.PrepareAsync操作在SetVideoSurface之后 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_0900, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_1000 - * @tc.name : 10.PrepareAsync操作调用3次 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_1000, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_PrepareAsync_1100 - * @tc.name : 11.PrepareAsync操作在每个可进行的操作后都调用一次 - * @tc.desc : test PrepareAsync -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_PrepareAsync_1100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/12.GetCurrentTime.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/12.GetCurrentTime.cpp deleted file mode 100644 index 77a1d7a5d491e9c8b2177edb64b59d0f552be850..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/api/12.GetCurrentTime.cpp +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerAPITest.h" -#include "player.h" -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_API_Seek_1500 - * @tc.name : 15.GET操作在每个可进行的操作后都调用一次 - * @tc.desc : test Seek -*/ -HWTEST_F(ActsPlayerAPITest, SUB_MEDIA_PLAYER_API_GetParameter_0100, Reliability | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - int32_t duration; - int32_t defaultDuration; - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(0, time); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_NE(RET_OK, player->GetDuration(duration)); - EXPECT_FALSE(player->IsPlaying()); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_NE(RET_OK, player->GetDuration(duration)); - EXPECT_FALSE(player->IsPlaying()); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_NE(RET_OK, player->GetDuration(duration)); - EXPECT_FALSE(player->IsPlaying()); - // prepare - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, player->GetDuration(defaultDuration)); - EXPECT_FALSE(player->IsPlaying()); - // play - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(defaultDuration, duration); - EXPECT_TRUE(player->IsPlaying()); - // seek - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(defaultDuration, duration); - // pause - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(defaultDuration, duration); - // seek duration - EXPECT_EQ(RET_OK, player->Seek(defaultDuration + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(defaultDuration, time); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(defaultDuration, duration); - // stop - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->GetDuration(duration)); - EXPECT_EQ(defaultDuration, duration); - EXPECT_FALSE(player->IsPlaying()); - // reset - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_NE(RET_OK, player->GetCurrentTime(time)); - EXPECT_NE(RET_OK, player->GetDuration(duration)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncAsyncTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncAsyncTest.cpp deleted file mode 100644 index d202970ea25f146a455f0a8b8c658de7c9bd1937..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncAsyncTest.cpp +++ /dev/null @@ -1,1203 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerFuncTest.h" -#include "securec.h" - -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0100 - * @tc.name : 001.进行播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0200 - * @tc.name : 002.进行暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0300 - * @tc.name : 003.进行恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0400 - * @tc.name : 004.进行停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0500 - * @tc.name : 005.进行结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0500, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0600 - * @tc.name : 006.暂停后恢复播放，再次暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0600, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0700 - * @tc.name : 007.暂停后结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0700, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0800 - * @tc.name : 008.暂停后恢复播放，再结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_0900 - * @tc.name : 009.停止播放后重新开始播放，暂停后恢复播放，再结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_0900, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1000 - * @tc.name : 010.停止播放后重新开始播放，暂停后结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1000, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1100 - * @tc.name : 011.停止播放后重新开始播放，再次结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1300 - * @tc.name : 013.停止播放后暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1300, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1400 - * @tc.name : 014.开始播放，进行Seek，再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1400, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1500 - * @tc.name : 015.开始播放，暂停后进行Seek，再恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1500, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1600 - * @tc.name : 016.开始播放，暂停后恢复播放，进行Seek，再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1600, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - for (int32_t i = 1; i < 4; i++) { - EXPECT_EQ(RET_OK, player->Seek(i * 1000, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i * 1000, time, DELTA_TIME); - } - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1700 - * @tc.name : 017.开始播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1800 - * @tc.name : 018.开始播放，进行Seek，停止播放， - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_1900 - * @tc.name : 019.开始播放，停止播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_1900, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2000 - * @tc.name : 020.开始播放，暂停后进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - } - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2100 - * @tc.name : 021.开始播放，暂停后进行Seek，停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - } - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2200 - * @tc.name : 022.开始播放，暂停后恢复播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2200, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000 + SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2300 - * @tc.name : 023.开始播放，暂停后恢复播放，进行Seek，停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2300, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2400 - * @tc.name : 024.开始播放，停止播放，进行Seek，重新播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2400, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2500 - * @tc.name : 025.进行Seek，Seek到文件开始的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2500, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Seek(FILE_BEGIN, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2600 - * @tc.name : 026.开始播放，停止播放，进行Seek,再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2600, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Pause()); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2700 - * @tc.name : 027.开始播放，停止播放，进行Seek，再进行恢复播放操作 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2700, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2800 - * @tc.name : 028.进行Seek，Seek到文件结尾的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_2900 - * @tc.name : 029.进行Seek，Seek到超过文件结尾的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_2900, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_3000 - * @tc.name : 030.进行Seek，Seek到文件随机的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_3000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime / 3, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(durationTime / 3, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_3100 - * @tc.name : 031.进行Seek，seek后开始进行基本播控操作 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_3100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - } - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_3200 - * @tc.name : 032.暂停时Seek到文件开始，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_3200, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(FILE_BEGIN, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_3300 - * @tc.name : 033.暂停时Seek到文件结尾，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_3300, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - sleep(PLAYING_TIME); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_03_3400 - * @tc.name : 034.暂停时Seek到超过文件结尾的位置，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_03_3400, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncTest.cpp deleted file mode 100644 index 6758776748ed2af6a9a95f76b16bec7890fca393..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerFuncTest.cpp +++ /dev/null @@ -1,1231 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsPlayerFuncTest.h" -#include "securec.h" - -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0100 - * @tc.name : 001.进行播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0200 - * @tc.name : 002.进行暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0300 - * @tc.name : 003.进行恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0400 - * @tc.name : 004.进行停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0500 - * @tc.name : 005.进行结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0500, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0600 - * @tc.name : 006.暂停后恢复播放，再次暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0600, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0700 - * @tc.name : 007.暂停后结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0700, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0800 - * @tc.name : 008.暂停后恢复播放，再结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_0900 - * @tc.name : 009.停止播放后重新开始播放，暂停后恢复播放，再结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_0900, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1000 - * @tc.name : 010.停止播放后重新开始播放，暂停后结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1000, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1100 - * @tc.name : 011.停止播放后重新开始播放，再次结束播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1300 - * @tc.name : 013.停止播放后暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1300, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1400 - * @tc.name : 014.开始播放，进行Seek，再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1400, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1500 - * @tc.name : 015.开始播放，暂停后进行Seek，再恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1500, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1600 - * @tc.name : 016.开始播放，暂停后恢复播放，进行Seek，再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1600, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - for (int32_t i = 1; i < 4; i++) { - EXPECT_EQ(RET_OK, player->Seek(i * 1000, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i * 1000, time, DELTA_TIME); - } - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1700 - * @tc.name : 017.开始播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1800 - * @tc.name : 018.开始播放，进行Seek，停止播放， - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_1900 - * @tc.name : 019.开始播放，停止播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_1900, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2000 - * @tc.name : 020.开始播放，暂停后进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - } - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2100 - * @tc.name : 021.开始播放，暂停后进行Seek，停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - } - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2200 - * @tc.name : 022.开始播放，暂停后恢复播放，进行Seek - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2200, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000 + SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2300 - * @tc.name : 023.开始播放，暂停后恢复播放，进行Seek，停止播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2300, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2400 - * @tc.name : 024.开始播放，停止播放，进行Seek，重新播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2400, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2500 - * @tc.name : 025.进行Seek，Seek到文件开始的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2500, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Seek(FILE_BEGIN, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2600 - * @tc.name : 026.开始播放，停止播放，进行Seek,再暂停 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2600, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_NE(RET_OK, player->Pause()); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2700 - * @tc.name : 027.开始播放，停止播放，进行Seek，再进行恢复播放操作 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2700, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_NE(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2800 - * @tc.name : 028.进行Seek，Seek到文件结尾的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2800, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_2900 - * @tc.name : 029.进行Seek，Seek到超过文件结尾的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_2900, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_3000 - * @tc.name : 030.进行Seek，Seek到文件随机的位置 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_3000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime / 3, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(durationTime / 3, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_3100 - * @tc.name : 031.进行Seek，seek后开始进行基本播控操作 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_3100, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - for (int32_t i = 0; i < durationTime; i = i + (durationTime / 3) + 1) { - EXPECT_EQ(RET_OK, player->Seek(i, SEEK_PREVIOUS_SYNC)); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(i, time, DELTA_TIME); - } - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_3200 - * @tc.name : 032.暂停时Seek到文件开始，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_3200, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Seek(FILE_BEGIN, SEEK_PREVIOUS_SYNC)); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_3300 - * @tc.name : 033.暂停时Seek到文件结尾，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_3300, Function | MediumTest | Level2) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - sleep(PLAYING_TIME); - - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_03_3400 - * @tc.name : 034.暂停时Seek到超过文件结尾的位置，恢复播放 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_03_3400, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateAsyncTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateAsyncTest.cpp deleted file mode 100644 index 78e6bdd538bb923cb25857e3c5a4691c01792b4a..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateAsyncTest.cpp +++ /dev/null @@ -1,1158 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerFuncTest.h" -#include "securec.h" - -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0100 - * @tc.name : 001.prepare-reset，销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0200 - * @tc.name : 002.prepare-reset，不销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0300 - * @tc.name : 003.prepare-stop-reset，销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0400 - * @tc.name : 004.prepare-stop-reset，不销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0600 - * @tc.name : 006.prepare-play-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0600, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0700 - * @tc.name : 007.prepare-seek-play-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0800 - * @tc.name : 008.prepare-seek-play-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0800, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, SEEK_TIME_5_SEC + PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_0900 - * @tc.name : 009.prepare-play-seek-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_0900, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1000 - * @tc.name : 010.prepare-play-seek-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1000, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1100 - * @tc.name : 011.prepare-play-seek-pause-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1200 - * @tc.name : 012.prepare-play-seek-pause-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1300 - * @tc.name : 013.prepare-play-seek-pause-stop-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1400 - * @tc.name : 014.prepare-play-seek-pause-stop-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1500 - * @tc.name : 015.prepare-play-stop-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1500, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1600 - * @tc.name : 016.prepare-play-stop-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1600, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1700 - * @tc.name : 017.prepare-stop，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1800 - * @tc.name : 018.pause-GetCurrentTime-play-GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1800, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000 * 2, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_1900 - * @tc.name : 019.pause-GetCurrentTime-seek-play-GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_1900, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC + PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2000 - * @tc.name : 020.play-seek EOS-GetCurrentTime-进入PlaybackCompleted,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsLooping()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2100 - * @tc.name : 021.seek EOS-GetCurrentTime-进入PlaybackCompleted,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2100, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsLooping()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2200 - * @tc.name : 022.play-seek EOS-GetCurrentTime,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2200, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time_before; - int32_t time_after; - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsLooping()); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_NEAR(time_after - time_before, PLAYING_TIME * 1000, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2300 - * @tc.name : 023.prepare-play-seek EOS-GetCurrentTime-进入PlaybackCompleted-stop,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2300, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - - EXPECT_FALSE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2400 - * @tc.name : 024.seek，seek随机+EOS附近 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2400, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime - 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(durationTime, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2500 - * @tc.name : 025.pause-seek-resume，不等seek完成 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2500, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC + PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2600 - * @tc.name : 026.seek，不等seek完成，seek - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2600, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2625 - * @tc.name : 026.seek，不等seek完成，pause - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2625, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2650 - * @tc.name : 026.seek，不等seek完成，GetDuration - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2650, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2651 - * @tc.name : 026.seek，不等seek完成，GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2651, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2675 - * @tc.name : 026.seek，不等seek完成，play - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2675, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2700 - * @tc.name : 027.prepare-seek未完成-seek eos-start-seek eos-start-stop - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2700, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2800 - * @tc.name : 028.prepare-start-pause-seek eos-stop-prepare-start-stop - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2800, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_2900 - * @tc.name : 029.prepare-seek eos-start-stop-prepare-seek eos-start-stop,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_2900, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t time_before; - int32_t time_after; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Async_Function_04_3000 - * @tc.name : 030.prepare-start-pause-seek eos-start-stop-prepare-start-pause-seek-start-stop,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Async_Function_04_3000, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t time_before; - int32_t time_after; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_NEAR(time_after - time_before, PLAYING_TIME * 1000, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->PrepareAsync()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(SEEK_TIME_2_SEC, time); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateTest.cpp deleted file mode 100644 index 41e6a21094c607dd15d3727964e513c72f2cc1a3..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/player/src/function/ActsPlayerStateTest.cpp +++ /dev/null @@ -1,1166 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ - -#include "ActsPlayerFuncTest.h" -#include "securec.h" - -using namespace std; -using namespace OHOS; -using namespace OHOS::Media; -using namespace testing::ext; -using namespace PlayerNameSpace; - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0100 - * @tc.name : 001.prepare-reset，销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0200 - * @tc.name : 002.prepare-reset，不销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0300 - * @tc.name : 003.prepare-stop-reset，销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0400 - * @tc.name : 004.prepare-stop-reset，不销毁播放器 - * @tc.desc : 播控 -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0600 - * @tc.name : 006.prepare-play-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0600, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_TRUE(player->IsPlaying()); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0700 - * @tc.name : 007.prepare-seek-play-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0800 - * @tc.name : 008.prepare-seek-play-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0800, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(time, SEEK_TIME_5_SEC + PLAYING_TIME * 1000, 1000); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_0900 - * @tc.name : 009.prepare-play-seek-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_0900, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1000 - * @tc.name : 010.prepare-play-seek-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1000, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1100 - * @tc.name : 011.prepare-play-seek-pause-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1100, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1200 - * @tc.name : 012.prepare-play-seek-pause-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1200, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1300 - * @tc.name : 013.prepare-play-seek-pause-stop-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1300, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1400 - * @tc.name : 014.prepare-play-seek-pause-stop-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1400, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1500 - * @tc.name : 015.prepare-play-stop-reset，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1500, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1600 - * @tc.name : 016.prepare-play-stop-reset，销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1600, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Release()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1700 - * @tc.name : 017.prepare-stop，不销毁播放器 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1700, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1800 - * @tc.name : 018.pause-GetCurrentTime-play-GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1800, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000 * 2, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_1900 - * @tc.name : 019.pause-GetCurrentTime-seek-play-GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_1900, Function | MediumTest | Level0) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - int32_t time; - ASSERT_EQ(RET_OK, player->SetSource(uri)); - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_FALSE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC, time, DELTA_TIME); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_2_SEC + PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2000 - * @tc.name : 020.play-seek EOS-GetCurrentTime-进入PlaybackCompleted,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2000, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsLooping()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2100 - * @tc.name : 021.seek EOS-GetCurrentTime-进入PlaybackCompleted,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2100, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_FALSE(player->IsLooping()); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2200 - * @tc.name : 022.play-seek EOS-GetCurrentTime,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2200, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time_before; - int32_t time_after; - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsLooping()); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_NEAR(time_after - time_before, PLAYING_TIME * 1000, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(FILE_BEGIN, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2300 - * @tc.name : 023.prepare-play-seek EOS-GetCurrentTime-进入PlaybackCompleted-stop,loop=0 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2300, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->SetLooping(false)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime + 1, SEEK_PREVIOUS_SYNC)); - - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - - EXPECT_FALSE(player->IsLooping()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2400 - * @tc.name : 024.seek，seek随机+EOS附近 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2400, Function | MediumTest | Level1) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime - 1, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(durationTime, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2500 - * @tc.name : 025.pause-seek-resume，不等seek完成 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2500, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_GE(time, SEEK_TIME_5_SEC); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2600 - * @tc.name : 026.seek，不等seek完成，seek - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2600, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_5_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(SEEK_TIME_5_SEC, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2625 - * @tc.name : 026.seek，不等seek完成，pause - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2625, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2650 - * @tc.name : 026.seek，不等seek完成，GetDuration - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2650, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2651 - * @tc.name : 026.seek，不等seek完成，GetCurrentTime - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2651, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2675 - * @tc.name : 026.seek，不等seek完成，play - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2675, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - testObj.mutexFlag_ = false; - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - testObj.mutexFlag_ = true; - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_NEAR(PLAYING_TIME * 1000, time, DELTA_TIME); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2700 - * @tc.name : 027.prepare-seek未完成-seek eos-start-seek eos-start-stop - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2700, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_FALSE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2800 - * @tc.name : 028.prepare-start-pause-seek eos-stop-prepare-start-stop - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2800, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Pause()); - - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - sleep(PLAYING_TIME); - EXPECT_TRUE(player->IsPlaying()); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_2900 - * @tc.name : 029.prepare-seek eos-start-stop-prepare-seek eos-start-stop,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_2900, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t time_before; - int32_t time_after; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} - -/** - * @tc.number : SUB_MEDIA_PLAYER_Local_Function_04_3000 - * @tc.name : 030.prepare-start-pause-seek eos-start-stop-prepare-start-pause-seek-start-stop,loop=1 - * @tc.desc : -*/ -HWTEST_F(ActsPlayerFuncTest, SUB_MEDIA_PLAYER_Local_Function_04_3000, Function | MediumTest | Level3) -{ - PlayerSignal testObj; - std::shared_ptr player = std::make_shared(&testObj); - ASSERT_NE(nullptr, player); - ASSERT_EQ(true, player->CreatePlayer()); - int32_t time; - int32_t time_before; - int32_t time_after; - int32_t durationTime; - std::string uri = GetUri(); - ASSERT_EQ(RET_OK, player->SetSource(uri)); - - sptr videoSurface = player->GetVideoSurface(g_sub_config); - EXPECT_EQ(RET_OK, player->SetVideoSurface(videoSurface)); - std::shared_ptr testCallback = std::make_shared(&testObj); - EXPECT_EQ(RET_OK, player->SetPlayerCallback(testCallback)); - - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->SetLooping(true)); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->GetDuration(durationTime)); - EXPECT_EQ(RET_OK, player->Seek(durationTime, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(durationTime, time); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, testCallback->WaitForState(PLAYER_PLAYBACK_COMPLETE)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_before)); - sleep(PLAYING_TIME); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time_after)); - EXPECT_NEAR(time_after - time_before, PLAYING_TIME * 1000, DELTA_TIME); - EXPECT_EQ(RET_OK, player->Stop()); - ASSERT_EQ(RET_OK, player->Prepare()); - EXPECT_EQ(RET_OK, player->Play()); - EXPECT_EQ(RET_OK, player->Pause()); - EXPECT_EQ(RET_OK, player->Seek(SEEK_TIME_2_SEC, SEEK_PREVIOUS_SYNC)); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(SEEK_TIME_2_SEC, time); - EXPECT_EQ(RET_OK, player->Stop()); - EXPECT_EQ(RET_OK, player->GetCurrentTime(time)); - EXPECT_EQ(FILE_BEGIN, time); - EXPECT_EQ(RET_OK, player->Reset()); - EXPECT_EQ(RET_OK, testCallback->errorNum); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsAudioRecoederTest.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsAudioRecoederTest.h deleted file mode 100644 index 82fd9211484274de148281246a98aa6b172d9ad6..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsAudioRecoederTest.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#ifndef RECODER_DEMO_TEST_H -#define RECODER_DEMO_TEST_H - -#include "gtest/gtest.h" -#include "recorder.h" - -namespace OHOS { -namespace Media { -struct AudioRecorderConfig { - int32_t audioSourceId; - int32_t audioEncodingBitRate; - int32_t channelCount; - int32_t duration; - std::string outPath; - int32_t sampleRate; - AudioCodecFormat audioFormat; - AudioSourceType inputSource; - OutputFormatType outPutFormat; -}; - -class ActsAudioRecorderTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(void); - void TearDown(void); - void ConfigAudioRecorder(std::shared_ptr recorder, AudioRecorderConfig audioConfig); - void AudioRecorderStart(std::shared_ptr recorder); -}; - -class TestAudioRecorderCallback : public RecorderCallback { -public: - void OnError(int32_t errorType, int32_t errorCode); - void OnInfo(int32_t type, int32_t extra); -}; -} -} -#endif \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsVideoRecorderTest.h b/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsVideoRecorderTest.h deleted file mode 100644 index 404a9d956671c2b29a9e18c0ea06670091c01d93..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/include/ActsVideoRecorderTest.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#ifndef RECODER_VIDEO_TEST_H -#define RECODER_VIDEO_TEST_H - -#include "gtest/gtest.h" -#include "recorder.h" - -namespace OHOS { -namespace Media { -struct VideoRecorderConfig { - int32_t audioSourceId; - int32_t videoSourceId; - int32_t audioEncodingBitRate; - int32_t channelCount; - int32_t duration; - int32_t width; - int32_t height; - int32_t frameRate; - int32_t videoEncodingBitRate; - int32_t sampleRate; - double captureFps; - std::string outPath; - AudioCodecFormat audioFormat; - AudioSourceType aSource; - OutputFormatType outPutFormat; - VideoSourceType vSource; - VideoCodecFormat videoFormat; -}; - -class ActsVideoRecorderTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(void); - void TearDown(void); - void ConfigvideoRecorder(std::shared_ptr recorder, VideoRecorderConfig videoConfig, bool isAudio); - void VideoRecorderStart(std::shared_ptr recorder); -}; - -class TestVideoRecorderCallback : public RecorderCallback { -public: - void OnError(int32_t errorType, int32_t errorCode); - void OnInfo(int32_t type, int32_t extra); -}; -} -} -#endif \ No newline at end of file diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsAudioRecoederTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsAudioRecoederTest.cpp deleted file mode 100644 index dd26dc5628d69ebbd89b1822a941505f13a20732..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsAudioRecoederTest.cpp +++ /dev/null @@ -1,152 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsAudioRecoederTest.h" -#include "mediatest_log.h" - -using namespace std; -using namespace OHOS::Media; -using namespace testing::ext; - -static AudioRecorderConfig g_audioRecorderConfig = { - 0, - 48000, - 2, - 60, - "/data/recorder", - 48000, - AAC_LC, - AUDIO_MIC, - FORMAT_M4A, -}; - -void TestAudioRecorderCallback::OnError(int32_t errorType, int32_t errorCode) -{ - MEDIA_INFO_LOG("OnError errorType is %d, errorCode is %d", errorType, errorCode); -} - -void TestAudioRecorderCallback::OnInfo(int32_t type, int32_t extra) -{ - MEDIA_INFO_LOG("OnInfo type is %d, extra is %d", type, extra); -} - -void ActsAudioRecorderTest::SetUpTestCase(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::SetUpTestCase"); -} - -void ActsAudioRecorderTest::TearDownTestCase(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::TearDownTestCase"); -} - -void ActsAudioRecorderTest::SetUp(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::SetUp"); -} - -void ActsAudioRecorderTest::TearDown(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::TearDown"); -} - -void ActsAudioRecorderTest::ConfigAudioRecorder(std::shared_ptr recorder, AudioRecorderConfig audioConfig) -{ - std::shared_ptr testCallback = std::make_shared(); - ASSERT_NE(nullptr, testCallback); - EXPECT_EQ(0, recorder->SetAudioSource(audioConfig.inputSource, audioConfig.audioSourceId)); - EXPECT_EQ(0, recorder->SetOutputFormat(audioConfig.outPutFormat)); - EXPECT_EQ(0, recorder->SetAudioEncoder(audioConfig.audioSourceId, audioConfig.audioFormat)); - EXPECT_EQ(0, recorder->SetAudioSampleRate(audioConfig.audioSourceId, audioConfig.sampleRate)); - EXPECT_EQ(0, recorder->SetAudioChannels(audioConfig.audioSourceId, audioConfig.channelCount)); - EXPECT_EQ(0, recorder->SetAudioEncodingBitRate(audioConfig.audioSourceId, audioConfig.audioEncodingBitRate)); - EXPECT_EQ(0, recorder->SetMaxDuration(audioConfig.duration)); - EXPECT_EQ(0, recorder->SetOutputPath(audioConfig.outPath)); - EXPECT_EQ(0, recorder->SetRecorderCallback(testCallback)); -} - -void ActsAudioRecorderTest::AudioRecorderStart(std::shared_ptr recorder) -{ - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(2); - EXPECT_EQ(0, recorder->Stop(false)); - EXPECT_EQ(0, recorder->Reset()); - EXPECT_EQ(0, recorder->Release()); -} - -/* * - * @tc.number : SUB_MEDIA_RECORDER_Codec_AAC_Function_0100 - * @tc.name : 01.set audio format to AAC - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsAudioRecorderTest, SUB_MEDIA_RECORDER_Codec_AAC_Function_0100, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsAudioRecorderTest::ConfigAudioRecorder(recorder, g_audioRecorderConfig); - ActsAudioRecorderTest::AudioRecorderStart(recorder); -} - -/* * - * @tc.number : SUB_MEDIA_RECORDER_Codec_AAC_Function_0300 - * @tc.name : 03.Set different samplerate 8-96KHz - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsAudioRecorderTest, SUB_MEDIA_RECORDER_Codec_AAC_Function_0300, Function | MediumTest | Level0) -{ - for (int i = 8000; i < 96000; i = i + 10000) { - g_audioRecorderConfig.sampleRate = i; - g_audioRecorderConfig.outPath = "/data/recorder"; - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsAudioRecorderTest::ConfigAudioRecorder(recorder, g_audioRecorderConfig); - ActsAudioRecorderTest::AudioRecorderStart(recorder); - } -} - -/* * - * @tc.number : SUB_MEDIA_RECORDER_Format_MP4_Function_05_0200 - * @tc.name : 02.Set outPutFormat to FORMAT_MPEG_4 - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsAudioRecorderTest, SUB_MEDIA_RECORDER_Format_MP4_Function_05_0200, Function | MediumTest | Level0) -{ - g_audioRecorderConfig.outPutFormat = FORMAT_MPEG_4; - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsAudioRecorderTest::ConfigAudioRecorder(recorder, g_audioRecorderConfig); - ActsAudioRecorderTest::AudioRecorderStart(recorder); -} - -/* * - * @tc.number : SUB_MEDIA_RECORDER_Function_09_01_0100 - * @tc.name : 001.Stopping Recording in DRAIN Mode When Recording Pure Audio Files - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsAudioRecorderTest, SUB_MEDIA_RECORDER_Function_09_01_0100, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsAudioRecorderTest::ConfigAudioRecorder(recorder, g_audioRecorderConfig); - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(5); - EXPECT_EQ(0, recorder->Stop(true)); - EXPECT_EQ(0, recorder->Release()); -} diff --git a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsVideoRecorderTest.cpp b/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsVideoRecorderTest.cpp deleted file mode 100644 index f954d4ce4ffba8c3978b0e9956b63fc31badf65a..0000000000000000000000000000000000000000 --- a/multimedia/audio/audio_native_standard/media_cpp_test_standard/recorder/src/fuction/ActsVideoRecorderTest.cpp +++ /dev/null @@ -1,239 +0,0 @@ -/* - * Copyright (C) 2021 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. - */ -#include "ActsVideoRecorderTest.h" -#include "mediatest_log.h" - -using namespace std; -using namespace OHOS::Media; -using namespace testing::ext; - -static VideoRecorderConfig g_videoRecorderConfig = { - 0, - 0, - 48000, - 2, - 60, - 1920, - 1080, - 30, - 48000, - 48000, - 30, - "/data/recorder", - AAC_LC, - AUDIO_MIC, - FORMAT_MPEG_4, - VIDEO_SOURCE_SURFACE_ES, - H264, -}; - -static int g_videoWidth[3] = {1920, 1280, 720}; -static int g_videoHeight[3] = {1080, 720, 480}; - -void TestVideoRecorderCallback::OnError(int32_t errorType, int32_t errorCode) -{ - MEDIA_INFO_LOG("OnError errorType is %d, errorCode is %d", errorType, errorCode); -} - -void TestVideoRecorderCallback::OnInfo(int32_t type, int32_t extra) -{ - MEDIA_INFO_LOG("OnInfo type is %d, extra is %d", type, extra); -} - -void ActsVideoRecorderTest::SetUpTestCase(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::SetUpTestCase"); -} - -void ActsVideoRecorderTest::TearDownTestCase(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::TearDownTestCase"); -} - -void ActsVideoRecorderTest::SetUp(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::SetUp"); -} - -void ActsVideoRecorderTest::TearDown(void) -{ - MEDIA_INFO_LOG("ActsAudioRecorderTest::TearDown"); -} - -void ActsVideoRecorderTest::ConfigvideoRecorder(std::shared_ptr recorder, - VideoRecorderConfig videoConfig, bool isAudio) -{ - std::shared_ptr testCallback = std::make_shared(); - ASSERT_NE(nullptr, testCallback); - EXPECT_EQ(0, recorder->SetVideoSource(videoConfig.vSource, videoConfig.videoSourceId)); - if (isAudio) { - EXPECT_EQ(0, recorder->SetAudioSource(videoConfig.aSource, videoConfig.audioSourceId)); - } - EXPECT_EQ(0, recorder->SetOutputFormat(videoConfig.outPutFormat)); - EXPECT_EQ(0, recorder->SetVideoEncoder(videoConfig.videoSourceId, videoConfig.videoFormat)); - EXPECT_EQ(0, recorder->SetVideoSize(videoConfig.videoSourceId, videoConfig.width, videoConfig.height)); - EXPECT_EQ(0, recorder->SetVideoFrameRate(videoConfig.videoSourceId, videoConfig.frameRate)); - EXPECT_EQ(0, recorder->SetVideoEncodingBitRate(videoConfig.videoSourceId, videoConfig.videoEncodingBitRate)); - EXPECT_EQ(0, recorder->SetCaptureRate(videoConfig.videoSourceId, videoConfig.captureFps)); - if (isAudio) { - EXPECT_EQ(0, recorder->SetAudioEncoder(videoConfig.audioSourceId, videoConfig.audioFormat)); - EXPECT_EQ(0, recorder->SetAudioSampleRate(videoConfig.audioSourceId, videoConfig.sampleRate)); - EXPECT_EQ(0, recorder->SetAudioChannels(videoConfig.audioSourceId, videoConfig.channelCount)); - EXPECT_EQ(0, recorder->SetAudioEncodingBitRate(videoConfig.audioSourceId, videoConfig.audioEncodingBitRate)); - } - EXPECT_EQ(0, recorder->SetMaxDuration(videoConfig.duration)); - EXPECT_EQ(0, recorder->SetOutputPath(videoConfig.outPath)); - EXPECT_EQ(0, recorder->SetRecorderCallback(testCallback)); -} - -void ActsVideoRecorderTest::VideoRecorderStart(std::shared_ptr recorder) -{ - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(5); - EXPECT_EQ(0, recorder->Stop(false)); - EXPECT_EQ(0, recorder->Reset()); - EXPECT_EQ(0, recorder->Release()); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Codec_H264_Function_03_0100 - * @tc.name : 01.Local recording H264 - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Codec_H264_Function_03_0100, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - ActsVideoRecorderTest::VideoRecorderStart(recorder); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Codec_H264_Function_03_0200 - * @tc.name : 02.Local recording H264_1080P/720P/480P - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Codec_H264_Function_03_0200, Function | MediumTest | Level0) -{ - for (int i = 0; i < 3; i++) { - g_videoRecorderConfig.width = g_videoWidth[i]; - g_videoRecorderConfig.height = g_videoHeight[i]; - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - ActsVideoRecorderTest::VideoRecorderStart(recorder); - } -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Codec_H264_Function_03_0400 - * @tc.name : 04.Local recording H264_BitRate - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Codec_H264_Function_03_0400, Function | MediumTest | Level0) -{ - g_videoRecorderConfig.audioEncodingBitRate = 96000; - g_videoRecorderConfig.videoEncodingBitRate = 96000; - g_videoRecorderConfig.sampleRate = 96000; - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - ActsVideoRecorderTest::VideoRecorderStart(recorder); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Format_MP4_Function_05_0100 - * @tc.name : 01.Local recording H264 - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Format_MP4_Function_05_0100, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, false); - ActsVideoRecorderTest::VideoRecorderStart(recorder); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Format_MP4_Function_05_0300 - * @tc.name : 03.Local recording H264 and AAC - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Format_MP4_Function_05_0300, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - ActsVideoRecorderTest::VideoRecorderStart(recorder); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Function_06_0100 - * @tc.name : 001.Start - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Function_06_0100, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(5); - EXPECT_EQ(0, recorder->Release()); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Function_06_0400 - * @tc.name : 004.Start-Stop - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Function_06_0400, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(5); - EXPECT_EQ(0, recorder->Stop(false)); - EXPECT_EQ(0, recorder->Release()); -} - -/** - * @tc.number : SUB_MEDIA_RECORDER_Function_06_0500 - * @tc.name : 005.Start-Reset - * @tc.desc : The test case is successfully executed. - The video file can be played properly. -*/ -HWTEST_F(ActsVideoRecorderTest, SUB_MEDIA_RECORDER_Function_06_0500, Function | MediumTest | Level0) -{ - std::shared_ptr recorder = RecorderFactory::CreateRecorder(); - ASSERT_NE(nullptr, recorder); - ActsVideoRecorderTest::ConfigvideoRecorder(recorder, g_videoRecorderConfig, true); - EXPECT_EQ(0, recorder->Prepare()); - EXPECT_EQ(0, recorder->Start()); - sleep(5); - EXPECT_EQ(0, recorder->Reset()); - EXPECT_EQ(0, recorder->Release()); -} \ No newline at end of file diff --git a/multimedia/media/media_js_test_standard/src/main/js/test/List.test.js b/multimedia/media/media_js_test_standard/src/main/js/test/List.test.js deleted file mode 100644 index c636ae4f24aa6512ce7f50b0fc17c75627aa953f..0000000000000000000000000000000000000000 --- a/multimedia/media/media_js_test_standard/src/main/js/test/List.test.js +++ /dev/null @@ -1,2 +0,0 @@ -require('../test/fuction/media_player/PlayerLocalTestAudioFUNC.test.js'); -require('../test/reliability/media_player/PlayerLocalTestAudioAPI.test.js'); diff --git a/multimedia/media/media_js_test_standard/src/main/js/test/fuction/media_player/PlayerLocalTestAudioFUNC.test.js b/multimedia/media/media_js_test_standard/src/main/js/test/fuction/media_player/PlayerLocalTestAudioFUNC.test.js deleted file mode 100644 index 781c004ad124d1bae3b44b2fff813db3db03a9ab..0000000000000000000000000000000000000000 --- a/multimedia/media/media_js_test_standard/src/main/js/test/fuction/media_player/PlayerLocalTestAudioFUNC.test.js +++ /dev/null @@ -1,887 +0,0 @@ -/* - * Copyright (C) 2021 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 media from '@ohos.multimedia.media' -import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' - -describe('PlayerLocalTestAudioFUNC', function () { - var audioPlayer = media.createAudioPlayer(); - var audioSource = "data/media/audio/Homey.mp3"; - var PLAY_TIME = 3000; - var DURATION_TIME = 89239; - var SEEK_TIME = 5000; - var DELTA_TIME = 1000; - var ENDSTATE = 0; - var SRCSTATE = 1; - var PLAYSTATE = 2; - var PAUSESTATE = 3; - var STOPSTATE = 4; - var RESETSTATE = 5; - var SEEKSTATE = 6; - var VOLUMESTATE = 7; - var RELEASESTATE = 8; - var ERRORSTATE = 9; - var FINISHSTATE = 10; - var LOOPSTATE = 11; - var NOERROR = 0; - var STEPERRCODE = 38; - var SEEKERROR = 'seekError'; - var PAUSEERROR = 'pauseError'; - var errCode = NOERROR; - beforeAll(function () { - console.info("beforeAll case"); - }) - - beforeEach(function () { - console.info("beforeEach case"); - }) - - afterEach(function () { - console.info("afterEach case"); - }) - - afterAll(function () { - console.info("afterAll case"); - }) - - var sleep = function(time) { - for(var t = Date.now(); Date.now() - t <= time;); - }; - - var initAudioPlayer = function() { - audioPlayer = media.createAudioPlayer(); - } - - var nextStep = function(mySteps, done) { - if (mySteps[0] == ENDSTATE) { - done(); - return; - } - switch (mySteps[0]) { - case SRCSTATE: - console.info(`case to prepare`); - audioPlayer.src = audioSource; - break; - case PLAYSTATE: - console.info(`case to play`); - audioPlayer.play(); - break; - case PAUSESTATE: - console.info(`case to pause`); - audioPlayer.pause(); - break; - case STOPSTATE: - console.info(`case to stop`); - audioPlayer.stop(); - break; - case RESETSTATE: - console.info(`case to reset`); - audioPlayer.reset(); - break; - case SEEKSTATE: - console.info(`case seek to time is ${mySteps[1]}`); - audioPlayer.seek(mySteps[1]); - break; - case VOLUMESTATE: - console.info(`case to setVolume`); - audioPlayer.setVolume(mySteps[1]); - break; - case RELEASESTATE: - console.info(`case to release`); - mySteps.shift(); - audioPlayer.release(); - break; - case LOOPSTATE: - audioPlayer.loop = mySteps[1]; - mySteps.shift(); - mySteps.shift(); - nextStep(mySteps, done); - break; - default: - break; - } - } - var setCallback = function(mySteps, done) { - console.info(`case setCallback`); - audioPlayer.on('dataLoad', () => { - mySteps.shift(); - console.info(`case dataLoad called`); - expect(audioPlayer.currentTime).assertEqual(0); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('paused'); - nextStep(mySteps, done); - }); - - audioPlayer.on('play', () => { - mySteps.shift(); - console.info(`case play called`); - console.info(`case play currentTime is ${audioPlayer.currentTime}`); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - if (mySteps[0] == FINISHSTATE) { - console.info(`case wait for finish`); - return; - } - expect(audioPlayer.state).assertEqual('playing'); - sleep(PLAY_TIME); - nextStep(mySteps, done); - }); - - audioPlayer.on('pause', () => { - mySteps.shift(); - console.info(`case pause called`); - console.info(`case pause currentTime is ${audioPlayer.currentTime}`); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('paused'); - nextStep(mySteps, done); - }); - - audioPlayer.on('reset', () => { - mySteps.shift(); - console.info(`case reset called`); - expect(audioPlayer.state).assertEqual('idle'); - nextStep(mySteps, done); - }); - - audioPlayer.on('stop', () => { - mySteps.shift(); - console.info(`case stop called`); - expect(audioPlayer.currentTime).assertEqual(0); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('stopped'); - nextStep(mySteps, done); - }); - - audioPlayer.on('timeUpdate', (seekDoneTime) => { - if (typeof (seekDoneTime) == "undefined") { - console.info(`case seek filed,errcode is ${seekDoneTime}`); - return; - } - mySteps.shift(); - mySteps.shift(); - console.info(`case seekDoneTime is ${seekDoneTime}`); - console.info(`case seek called`); - expect(audioPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME); - console.info(`case loop is ${audioPlayer.loop}`); - if ((audioPlayer.loop == true) && (seekDoneTime == DURATION_TIME)) { - console.info('case loop is true'); - sleep(PLAYSTATE); - } - if (seekDoneTime < audioPlayer.duration || audioPlayer.state == "paused") { - nextStep(mySteps, done); - } - }); - - audioPlayer.on('volumeChange', () => { - console.info(`case setvolume called`); - mySteps.shift(); - mySteps.shift(); - if (audioPlayer.state == "playing") { - sleep(PLAY_TIME); - } - nextStep(mySteps, done); - }); - - audioPlayer.on('finish', () => { - mySteps.shift(); - expect(audioPlayer.state).assertEqual('stopped'); - expect(audioPlayer.currentTime).assertClose(audioPlayer.duration, DELTA_TIME); - console.info(`case finish called`); - nextStep(mySteps, done); - }); - - audioPlayer.on('error', (err) => { - console.info(`case error called,errName is ${err.name}`); - console.info(`case error called,errCode is ${err.code}`); - console.info(`case error called,errMessage is ${err.message}`); - expect(err.code).assertEqual(errCode); - if ((mySteps[0] == SEEKSTATE) || (mySteps[0] == VOLUMESTATE)) { - expect(mySteps[2]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[3]); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - } else { - expect(mySteps[1]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[2]); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - } - nextStep(mySteps, done); - }); - }; - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0100 - * @tc.name : 001.本地音频初始状态：进行播放 - * @tc.desc : 1.播放成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0200 - * @tc.name : 002.本地音频播放状态：进行暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0300 - * @tc.name : 003.本地音频暂停状态：进行恢复播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0500 - * @tc.name : 005.本地音频播放状态：进行结束播放 - * @tc.desc : 1.播放成功 - 2.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0600 - * @tc.name : 006.本地音频播放状态：暂停后恢复播放，再次暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Pause成功 - 5.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0600', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0700 - * @tc.name : 007.本地音频暂停状态：暂停后结束播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0800 - * @tc.name : 008.本地音频播放状态：暂停后恢复播放，再结束播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.播放成功 - 4.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0900 - * @tc.name : 009.本地音频播放状态：停止播放后重新开始播放，暂停后恢复播放，再结束播放 - * @tc.desc : 1.播放成功 - 2.Stop成功 -　　　　　　　　　　　　　　　　3.播放成功 -　　　　　　　　　　　　　　　　4.Pause成功 -　　　　　　　　　　　　　　　　5.Play成功 -　　　　　　　　　　　　　　　　6.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_0900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, - PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1000 - * @tc.name : 010.本地音频暂停状态：停止播放后重新开始播放，暂停后结束播放 - * @tc.desc : 1.播放成功 -　　　　　　　　　　　　　　　　2.Pause成功 -　　　　　　　　　　　　　　　　3.Stop成功 -　　　　　　　　　　　　　　　　4.播放成功 -　　　　　　　　　　　　　　　　5.Pause成功 -　　　　　　　　　　　　　　　　6.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, - PAUSESTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1100 - * @tc.name : 011.本地音频播放状态：停止播放后重新开始播放，再次结束播放 - * @tc.desc : 1.播放成功 - 　　　　　　　　　　　　　 2.Stop成功 - 　　　　　　　　　　　　　 3.播放成功 - 　　　　　　　　　　　　　 4.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1200 - * @tc.name : 012.本地音频暂停状态：暂停后再次play - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.播放成功 - 4.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level ２ - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1300 - * @tc.name : 013.本地音频停止状态：停止播放后暂停 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Pause失败 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1300', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1400 - * @tc.name : 014.本地音频初始状态：开始播放，进行Seek，再暂停 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Pause成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, 0, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1500 - * @tc.name : 015.本地音频初始状态：开始播放，暂停后进行Seek，再恢复播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 - 4.Play成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, SEEKSTATE, DURATION_TIME / 2, - SEEKSTATE, audioPlayer.duration, PLAYSTATE, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1600 - * @tc.name : 016.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek，再暂停 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Seek成功 - 5.pause成功 - 6.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1600', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1700 - * @tc.name : 017.本地音频初始状态：开始播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 2, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1800 - * @tc.name : 018.本地音频初始状态：开始播放，进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Stop成功 - 4.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 2, - STOPSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1900 - * @tc.name : 019.本地音频初始状态：开始播放，停止播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_1900', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, 0, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2000 - * @tc.name : 020.本地音频初始状态：开始播放，暂停后进行Seek - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2100 - * @tc.name : 021.本地音频初始状态：开始播放，暂停后进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Seek成功 - 4.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME / 2, - STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2200 - * @tc.name : 022.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Seek成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2300 - * @tc.name : 023.本地音频初始状态：开始播放，暂停后恢复播放，进行Seek，停止播放 - * @tc.desc : 1.播放成功 - 2.Pause成功 - 3.Play成功 - 4.Stop成功 - 5.Seek成功 - 6.Stop成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, SEEKSTATE, 0, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2400 - * @tc.name : 024.本地音频初始状态：开始播放，停止播放，进行Seek，重新播放 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - 4.重新播放成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2400', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, 0, ERRORSTATE, SEEKERROR, - RESETSTATE, SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2500 - * @tc.name : 025.本地音频播放状态：进行Seek，Seek到文件开始的位置 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, 0, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2600 - * @tc.name : 026.本地音频初始状态：开始播放，停止播放，进行Seek,再暂停 - * @tc.desc : 1.播放成功 - 2.Stop成功 - 3.Seek失败 - 4.Pause失败 - 5.Reset成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2600', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, - SEEKERROR, PAUSESTATE, ERRORSTATE, PAUSEERROR, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2700 - * @tc.name : 027.本地音频初始状态：开始播放，停止播放，进行Seek，再进行恢复播放操作 - * @tc.desc : 1.播放成功； - 2.Stop成功； - 3.Seek失败 - 4.恢复播放成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2700', 0, async function (done) { - errCode = STEPERRCODE; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, - SEEKERROR, RESETSTATE, SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2800 - * @tc.name : 028.本地音频播放状态：进行Seek，Seek到文件结尾的位置 - * @tc.desc : 1.播放成功 - 2.Seek成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2800', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2900 - * @tc.name : 029.本地音频播放状态：进行Seek，Seek到超过文件结尾的位置 - * @tc.desc : 1.播放成功 - 2.Seek到结尾 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_2900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, - FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3000 - * @tc.name : 030.本地音频播放状态：进行Seek，Seek到文件随机的位置 - * @tc.desc : 1.Seek成功，查看currenTime与seek到的位置一致 - 2.当前位置为seek设置的随机位置 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME / 5, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3200 - * @tc.name : 032.本地音频播放状态：暂停时Seek到文件开始，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, 0, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3300 - * @tc.name : 033.本地音频播放状态：暂停时Seek到文件结尾，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME, PLAYSTATE, - FINISHSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3400 - * @tc.name : 034.本地音频播放状态：暂停时Seek到超过文件结尾的位置，恢复播放 - * @tc.desc : 1.播放成功 - 2.暂停成功 - 3.Seek成功 - 4.Play成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, PLAYSTATE, - FINISHSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3500 - * @tc.name : 035.本地音频播放状态：播放时Seek到超过文件结尾的位置，再重新开始播放 - * @tc.desc : 1.播放成功 - 2.Seek成功 - 3.finish回调函数触发，并重新开始播放 - 3.Play成功 - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 3 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DELTA_TIME, - FINISHSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3600 - * @tc.name : 036.支持设置循环播放 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : Function test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_LOCAL_AUDIO_Function_04_3600', 0, async function (done) { - var playCount = 0; - var seekCount = 0; - var testAudioPlayer = media.createAudioPlayer(); - testAudioPlayer.on('dataLoad', () => { - console.info(`case dataLoad called`); - expect(testAudioPlayer.currentTime).assertEqual(0); - expect(testAudioPlayer.duration).assertEqual(DURATION_TIME); - expect(testAudioPlayer.state).assertEqual('paused'); - testAudioPlayer.loop = true; - testAudioPlayer.play(); - }); - testAudioPlayer.on('play', () => { - console.info(`case play called`); - console.info(`case play currentTime is ${testAudioPlayer.currentTime}`); - expect(testAudioPlayer.duration).assertEqual(DURATION_TIME); - expect(testAudioPlayer.state).assertEqual('playing'); - sleep(PLAY_TIME); - if (playCount == 1) { - return; - } - playCount++ - testAudioPlayer.seek(DURATION_TIME); - }); - testAudioPlayer.on('timeUpdate', (seekDoneTime) => { - if (typeof (seekDoneTime) == "undefined") { - console.info(`case seek filed,errcode is ${seekDoneTime}`); - return; - } - if (seekCount == 1) { - testAudioPlayer.reset(); - return; - } - seekCount++ - console.info(`case seekDoneTime is ${seekDoneTime}`); - console.info(`case seek called`); - expect(testAudioPlayer.currentTime + 1).assertClose(seekDoneTime + 1, DELTA_TIME); - }); - testAudioPlayer.on('finish', () => { - expect(testAudioPlayer.state).assertEqual('playing'); - console.info(`case finish called`); - }); - testAudioPlayer.on('reset', () => { - expect(testAudioPlayer.state).assertEqual('idle'); - console.info(`case reset called`); - testAudioPlayer.release(); - done(); - }); - testAudioPlayer.src = audioSource; - }) - -}) \ No newline at end of file diff --git a/multimedia/media/media_js_test_standard/src/main/js/test/reliability/media_player/PlayerLocalTestAudioAPI.test.js b/multimedia/media/media_js_test_standard/src/main/js/test/reliability/media_player/PlayerLocalTestAudioAPI.test.js deleted file mode 100644 index c0adf89eacb75d01f18c735920523bdca050db4e..0000000000000000000000000000000000000000 --- a/multimedia/media/media_js_test_standard/src/main/js/test/reliability/media_player/PlayerLocalTestAudioAPI.test.js +++ /dev/null @@ -1,1124 +0,0 @@ -/* - * Copyright (C) 2021 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 media from '@ohos.multimedia.media' -import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' - -describe('PlayerLocalTestAudioAPI', function () { - var audioPlayer = media.createAudioPlayer(); - var audioSource = "data/media/audio/Homey.mp3"; - var PLAY_TIME = 3000; - var ENDSTATE = 0; - var SRCSTATE = 1; - var PLAYSTATE = 2; - var PAUSESTATE = 3; - var STOPSTATE = 4; - var RESETSTATE = 5; - var SEEKSTATE = 6; - var VOLUMESTATE = 7; - var RELEASESTATE = 8; - var ERRORSTATE = 9; - var FINISHSTATE = 10; - var LOOPSTATE = 11; - var NOERROR = 0; - var DURATION_TIME = 89239; - var SEEK_TIME = 5000; - var VOLUMEVALUE = 0.1; - var DELTA_TIME = 1000; - var SRCERROR = 'sourceError'; - var SEEKERROR = 'seekError'; - var PAUSEERROR = 'pauseError'; - var PLAYERROR = 'playError'; - var STOPERROR = 'stopError'; - var errCode = NOERROR; - var ERRSTEP = 38; - var ERRSRC = 22; - beforeAll(function () { - console.info("beforeAll case"); - }) - - beforeEach(function () { - console.info("beforeEach case"); - }) - - afterEach(function () { - console.info("afterEach case"); - errCode = NOERROR; - }) - - afterAll(function () { - console.info("afterAll case"); - }) - - var sleep = function(time) { - for(var t = Date.now();Date.now() - t <= time;); - }; - - var initAudioPlayer = function() { - audioPlayer.release(); - audioPlayer = media.createAudioPlayer(); - } - - var nextStep = function(mySteps, done) { - if (mySteps[0] == ENDSTATE) { - if (mySteps[1] == false || mySteps[1] == true) { - expect(audioPlayer.loop).assertEqual(mySteps[1]); - } - done(); - return; - } - switch (mySteps[0]) { - case SRCSTATE: - console.info(`case to prepare`); - audioPlayer.src = audioSource; - break; - case PLAYSTATE: - console.info(`case to play`); - audioPlayer.play(); - break; - case PAUSESTATE: - console.info(`case to pause`); - audioPlayer.pause(); - break; - case STOPSTATE: - console.info(`case to stop`); - audioPlayer.stop(); - break; - case RESETSTATE: - console.info(`case to reset`); - audioPlayer.reset(); - break; - case SEEKSTATE: - console.info(`case seek to time is ${mySteps[1]}`); - audioPlayer.seek(mySteps[1]); - break; - case VOLUMESTATE: - console.info(`case to setVolume`); - audioPlayer.setVolume(mySteps[1]); - break; - case RELEASESTATE: - console.info(`case to release`); - mySteps.shift(); - audioPlayer.release(); - nextStep(mySteps, done); - break; - case LOOPSTATE: - audioPlayer.loop = mySteps[1]; - mySteps.shift(); - mySteps.shift(); - nextStep(mySteps, done); - break; - default: - break; - } - } - var setCallback = function(mySteps, done) { - console.info(`case setCallback`); - audioPlayer.on('dataLoad', () => { - mySteps.shift(); - console.info(`case dataLoad called`); - expect(audioPlayer.currentTime).assertEqual(0); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('paused'); - nextStep(mySteps, done); - }); - - audioPlayer.on('play', () => { - mySteps.shift(); - console.info(`case play called`); - console.info(`case play currentTime is ${audioPlayer.currentTime}`); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - if (mySteps[0] == FINISHSTATE) { - console.info(`case wait for finish`); - return; - } - expect(audioPlayer.state).assertEqual('playing'); - nextStep(mySteps, done); - }); - - audioPlayer.on('pause', () => { - mySteps.shift(); - console.info(`case pause called`); - console.info(`case pause currentTime is ${audioPlayer.currentTime}`); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('paused'); - nextStep(mySteps, done); - }); - - audioPlayer.on('reset', () => { - mySteps.shift(); - console.info(`case reset called`); - expect(audioPlayer.state).assertEqual('idle'); - nextStep(mySteps, done); - }); - - audioPlayer.on('stop', () => { - mySteps.shift(); - console.info(`case stop called`); - expect(audioPlayer.currentTime).assertEqual(0); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('stopped'); - nextStep(mySteps, done); - }); - - audioPlayer.on('timeUpdate', (seekDoneTime) => { - if (typeof (seekDoneTime) == "undefined") { - console.info(`case seek filed,errcode is ${seekDoneTime}`); - return; - } - mySteps.shift(); - mySteps.shift(); - console.info(`case seekDoneTime is ${seekDoneTime}`); - console.info(`case seek called`); - expect(audioPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME); - console.info(`case loop is ${audioPlayer.loop}`); - if ((audioPlayer.loop == true) && (seekDoneTime == DURATION_TIME)) { - console.info('case loop is true'); - sleep(PLAYSTATE); - } - if (seekDoneTime < audioPlayer.duration || audioPlayer.state == "paused") { - nextStep(mySteps, done); - } - }); - - audioPlayer.on('volumeChange', () => { - console.info(`case setvolume called`); - mySteps.shift(); - mySteps.shift(); - if (audioPlayer.state == "playing") { - sleep(PLAY_TIME); - } - nextStep(mySteps, done); - }); - - audioPlayer.on('finish', () => { - mySteps.shift(); - expect(audioPlayer.state).assertEqual('stopped'); - expect(audioPlayer.currentTime).assertClose(audioPlayer.duration, DELTA_TIME); - console.info(`case finish called`); - nextStep(mySteps, done); - }); - - audioPlayer.on('error', (err) => { - console.info(`case error called,errName is ${err.name}`); - console.info(`case error called,errCode is ${err.code}`); - console.info(`case error called,errMessage is ${err.message}`); - expect(err.code).assertEqual(errCode); - if ((mySteps[0] == SEEKSTATE) || (mySteps[0] == VOLUMESTATE)) { - expect(mySteps[2]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[3]); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - } else { - expect(mySteps[1]).assertEqual(ERRORSTATE); - expect(err.message).assertEqual(mySteps[2]); - mySteps.shift(); - mySteps.shift(); - mySteps.shift(); - } - nextStep(mySteps, done); - }); - }; - - /* * - * @tc.number : SUB_MEDIA_PLAYER_createAudioPlayer_API_0100 - * @tc.name : 01.创建一个音频播放器createAudioPlayer() - * @tc.desc : testcreateAudioPlayer - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_createAudioPlayer_API_0100', 0, async function (done) { - var audioPlayerTest = media.createAudioPlayer(); - expect(audioPlayerTest != null).assertTrue(); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0100 - * @tc.name : 01.play操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.play(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200 - * @tc.name : 02.play操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0200', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0300 - * @tc.name : 03.play操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0300', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0400 - * @tc.name : 04.play操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, SEEK_TIME, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0800 - * @tc.name : 08.play操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0800', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RESETSTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0900 - * @tc.name : 09.play操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Play_API_0900', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RELEASESTATE, PLAYSTATE, ERRORSTATE, PLAYERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0100 - * @tc.name : 01.pause操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.pause(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0200 - * @tc.name : 02.pause操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0300 - * @tc.name : 02.pause操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0300', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(PLAYSTATE, STOPSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0400 - * @tc.name : 04.pause操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, PAUSESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0800 - * @tc.name : 08.pause操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0800', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RESETSTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900 - * @tc.name : 09.pause操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, RELEASESTATE, PAUSESTATE, ERRORSTATE, PAUSEERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0100 - * @tc.name : 01.stop操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.stop(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0200 - * @tc.name : 02.stop操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0300 - * @tc.name : 03.stop操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0400 - * @tc.name : 04.stop操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, STOPSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0800 - * @tc.name : 08.stop操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0800', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Pause_API_0900 - * @tc.name : 09.stop操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Stop_API_0900', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, STOPSTATE, ERRORSTATE, STOPERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0100 - * @tc.name : 01.seek操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SEEKSTATE, SEEK_TIME, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - var seekTime = SEEK_TIME; - audioPlayer.seek(seekTime); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0200 - * @tc.name : 02.seek操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0300 - * @tc.name : 03.seek操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, SEEKSTATE, SEEK_TIME, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0500 - * @tc.name : 05.seek操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0500', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, SEEKSTATE, SEEK_TIME, ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0700 - * @tc.name : 07.seek操作调用3次 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, SEEKSTATE, 6000, SEEKSTATE, 7000, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0800 - * @tc.name : 08.seek到码流任意某一点(0~码流时长) - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0800', 0, async function (done) { - var randomTime = parseInt(Math.random()*(audioPlayer.duration + 1),10); - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, randomTime, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0900 - * @tc.name : 9.seek到起始位置(0) - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_0900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, 0, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1000 - * @tc.name : 10.seek到结束位置(码流时长) - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1100 - * @tc.name : 11.seek操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1100', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, SEEKSTATE, SEEK_TIME, - ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1200 - * @tc.name : 12.seek操作在release之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1200', 0, async function (done) { - errCode = ERRSTEP; - var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, SEEKSTATE, SEEK_TIME, - ERRORSTATE, SEEKERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1400 - * @tc.name : 14.seek到超出码流时长 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Seek_API_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, DURATION_TIME + DURATION_TIME, FINISHSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0200 - * @tc.name : 02.reset操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0300 - * @tc.name : 03.reset操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0400 - * @tc.name : 04.reset操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0500 - * @tc.name : 05.reset操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Reset_API_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, RESETSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0100 - * @tc.name : 01.release操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0100', 0, async function (done) { - var mySteps = new Array(RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.release(); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0200 - * @tc.name : 02.release操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0300 - * @tc.name : 03.release操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0400 - * @tc.name : 04.release操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0500 - * @tc.name : 05.release操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0700 - * @tc.name : 07.release操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Release_API_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, RELEASESTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0300 - * @tc.name : 003.播放文件名超长（255）的本地音频素材 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = "data/media/audio/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.mp3"; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0500 - * @tc.name : 005.播放文件名为“” - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0500', 0, async function (done) { - errCode = ERRSRC; - var mySteps = new Array(SRCSTATE, ERRORSTATE, SRCERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = ""; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0800 - * @tc.name : 008. 传入的地址不存在 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 0 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_URI_API_0800', 0, async function (done) { - errCode = 331350552; - var mySteps = new Array(SRCSTATE, ERRORSTATE, SRCERROR, ENDSTATE); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = "data/media/audio/no.mp3"; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0100 - * @tc.name : 01.set loop true操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0100', 0, async function (done) { - initAudioPlayer(); - audioPlayer.loop = true; - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0200 - * @tc.name : 02.set loop true操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0300 - * @tc.name : 03.set loop true操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0300', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0400 - * @tc.name : 04.set loop true操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0500 - * @tc.name : 05.set loop true操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0500', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, LOOPSTATE, true, ENDSTATE, true); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0700 - * @tc.name : 07.set loop true操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0700', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, LOOPSTATE, true, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0800 - * @tc.name : 08.set loop false操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0800', 0, async function (done) { - initAudioPlayer(); - audioPlayer.loop = false; - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0900 - * @tc.name : 09.set loop false操作在play之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_0900', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1000 - * @tc.name : 10.set loop false操作在pause之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1000', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, PAUSESTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1100 - * @tc.name : 11.set loop false操作在stop之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1100', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, STOPSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1200 - * @tc.name : 12.set loop false操作在seek之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1200', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, SEEKSTATE, SEEK_TIME, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1400 - * @tc.name : 14.set loop false操作在reset之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Loop_API_1400', 0, async function (done) { - var mySteps = new Array(SRCSTATE, PLAYSTATE, RESETSTATE, LOOPSTATE, false, ENDSTATE, false); - initAudioPlayer(); - setCallback(mySteps, done); - audioPlayer.src = audioSource; - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0100 - * @tc.name : 01.获取参数操作在createAudioPlayer之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0100', 0, async function (done) { - initAudioPlayer(); - expect(audioPlayer.src).assertEqual(undefined); - expect(audioPlayer.duration).assertEqual(undefined); - expect(audioPlayer.currentTime).assertEqual(undefined); - expect(audioPlayer.state).assertEqual('idle'); - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - - /* * - * @tc.number : SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0200 - * @tc.name : 02.获取参数操作在setsrc之后 - * @tc.desc : - * @tc.size : MEDIUM - * @tc.type : API Test - * @tc.level : Level 2 - */ - it('SUB_MEDIA_PLAYER_AudioPlayer_Time_API_0200', 0, async function (done) { - initAudioPlayer(); - audioPlayer.src = audioSource; - sleep(PLAY_TIME); - expect(audioPlayer.src).assertEqual(audioSource); - expect(audioPlayer.currentTime).assertEqual(0); - expect(audioPlayer.duration).assertEqual(DURATION_TIME); - expect(audioPlayer.state).assertEqual('paused'); - expect(audioPlayer.loop).assertEqual(false); - done(); - }) - -})