diff --git a/multimedia/media/media_js_standard/AVPlayerTestBase.js b/multimedia/media/media_js_standard/AVPlayerTestBase.js index 88f2ebca40b6d04f6b010ba0b64fdefb27d60526..b609c55bd0cf24dea4a2dc7c5379849eda54457c 100644 --- a/multimedia/media/media_js_standard/AVPlayerTestBase.js +++ b/multimedia/media/media_js_standard/AVPlayerTestBase.js @@ -71,6 +71,16 @@ function toPreparePromise(avPlayer, playTest) { }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); } +async function preparePromise(avPlayer) { + if (typeof(avPlayer) == 'undefined') { + return; + } + await avPlayer.prepare().then(() => { + console.info('case prepare called'); + console.info('case avPlayer.duration: ' + avPlayer.duration); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + function addCnt(countArr) { if (countArr != null) { countArr[0]++; @@ -387,7 +397,7 @@ export function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } -function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTest, playTime, done) { +function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done) { let playPauseCount = 0; let surfaceID = globalThis.value; console.info(`case setAVPlayerPlayAndPauseWithCallBack in, surfaceID is ${surfaceID}`); @@ -399,7 +409,7 @@ function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTest, playTime, avPlayer.surfaceId = surfaceID; console.info('playPauseLoopWithCallBack play state is INITIALIZED') // step 1: initialized -> prepared -> play - toPreparePromise(avPlayer, playTest); + preparePromise(avPlayer); await sleep(2000); avPlayer.play() break; @@ -453,7 +463,7 @@ function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTest, playTime, }); } -export async function avPlayerWithCallBack(src, avPlayer, playTest, playTime, done) { +async function idle(src, avPlayer) { console.info(`case media source: ${src}`) await media.createAVPlayer().then((video) => { if (typeof(video) != 'undefined') { @@ -462,11 +472,15 @@ export async function avPlayerWithCallBack(src, avPlayer, playTest, playTime, do } else { console.error('case createAVPlayer failed'); expect().assertFail(); - done(); } }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); - setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTest, playTime, done); - setSource(avPlayer, src); + return avPlayer; +} + +export async function avPlayerWithCallBack(src, avPlayer, playTime, done) { + avPlayer = await idle(src, avPlayer) + setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done); + await setSource(avPlayer, src); } async function playToPauseLoop(avPlayer){ @@ -474,7 +488,7 @@ async function playToPauseLoop(avPlayer){ console.info('playToPauseLoop play success'); expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); }, (err) => { - console.error('playToPauseLoop play filed,error message is :' + err.message) + console.error('playToPauseLoop play filed,error message is :' + err.message) }) if(avPlayer.state == AV_PLAYER_STATE.PLAYING){ avPlayer.loop = true; @@ -489,44 +503,1656 @@ async function playToPauseLoop(avPlayer){ }) } -export async function avPlayerWithoutCallBack(src, avPlayer, playTest, done) { +export async function createToRelease(src, avPlayer, done) { + for(var i = 0;i < 1000; i++){ + let surfaceID = globalThis.value; + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('CreateToRelease setSource'); + if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { + avPlayer.surfaceId = surfaceID; + await avPlayer.release().then(() => { + console.info('CreateToRelease avPlayer from stop to release') + console.info(`case CreateToRelease loop is ${i}`); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + } + done(); +} + +export async function playToCompleted(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + playToCompletedLoop(src, avPlayer, done); + await setSource(avPlayer, src); +} + +async function playToCompletedLoop(src, avPlayer, done) { + let playToCompletedCount = 0; let surfaceID = globalThis.value; - console.info(`case avPlayerWithoutCallBack in, surfaceID is ${surfaceID}`); - console.info(`case media source: ${src}`) - await media.createAVPlayer().then((video) => { - if (typeof(video) != 'undefined') { - console.info('case createAVPlayer success'); - avPlayer = video; - } else { - console.error('case createAVPlayer failed'); - expect().assertFail(); + console.info(`case playToCompletedLoop in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('playToCompletedLoop play state is INITIALIZED') + // step 1: initialized -> prepared -> play + preparePromise(avPlayer); + await sleep(2000); + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + avPlayer.loop = false; + console.info('playToCompletedLoop play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + playToCompletedCount++; + if(playToCompletedCount == 1001){ + // step 4: playing -> stop -> release + avPlayer.stop().then(() => { + console.info('playToCompletedLoop avPlayer from play to stop') + avPlayer.release().then(() => { + console.info('playToCompletedLoop avPlayer from stop to release') + offCallback(avPlayer, ['stateChange', 'error']); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + // step 2: playing -> seek loop + avPlayer.seek(10034, media.SeekMode.SEEK_NEXT_SYNC) + console.info('playToCompletedLoop avPlayer from play to seek,time is :' + playToCompletedCount) + } + break; + case AV_PLAYER_STATE.COMPLETED: + expect(avPlayer.currentTime).assertEqual(avPlayer.duration); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); + console.info('playToCompletedLoop avPlayer from COMPLETED to play') + // step 3: COMPLETED -> play loop + avPlayer.play(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('error', async (err) => { + console.error(`case error called, errMessage is ${err.message}`); + expect().assertFail(); + await avPlayer.release().then(() => { + avPlayer = null; + done(); + }); + }); +} + +export async function seekLoop(src, avPlayer, done) { + let surfaceID = globalThis.value; + avPlayer = await idle(src, avPlayer) + seekLoopWithCallback(avPlayer); + await setSource(avPlayer, src); + if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { + avPlayer.surfaceId = surfaceID; + console.info('seekLoop case prepare success'); + preparePromise(avPlayer); + await sleep(2000); + } + await avPlayer.play().then(() => { + console.info('seekLoop play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('seekLoop play filed,error message is :' + err.message) + }) + if(avPlayer.state == AV_PLAYER_STATE.PLAYING){ + console.info('seekLoop avPlayer from play to seek') + // play seek loop 1000 times + for(var loopTime = 0;loopTime < 1000; loopTime++){ + avPlayer.seek(loopTime) + console.info(`case seekLoopWithCallback loopTime is ${loopTime}`); } + } + await avPlayer.stop().then(() => { + console.info('seekLoopWithCallback avPlayer from play to stop') + offCallback(avPlayer, ['stateChange', 'seekDone']); + avPlayer.release().then(() => { + console.info('seekLoopWithCallback avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); - setSource(avPlayer, src); - console.info('avPlayerWithoutCallBack setSource'); - avPlayer.surfaceId = surfaceID; +} + +async function seekLoopWithCallback(avPlayer) { + avPlayer.on('seekDone', async (seekDoneTime) => { + console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`); + }); +} + +export async function seekLoopWithoutCallback(src, avPlayer, done) { + let surfaceID = globalThis.value; + console.info(`case Initialized in, surfaceID is ${surfaceID}`); + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { - toPreparePromise(avPlayer, playTest); + avPlayer.surfaceId = surfaceID; + preparePromise(avPlayer); await sleep(2000); } - if(avPlayer.state == AV_PLAYER_STATE.PREPARED){ - console.info('avPlayerWithoutCallBack avPlayer from PREPARED to play') - // play to pause loop 1000 times - for(var i = 0;i < 1000; i++){ - await playToPauseLoop(avPlayer) - console.info(`case avPlayerWithoutCallBack playToPauseLoop is ${i}`); + await avPlayer.play().then(() => { + console.info('seekLoopWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('seekLoopWithoutCallback play filed,error message is :' + err.message) + }) + if(avPlayer.state == AV_PLAYER_STATE.PLAYING){ + console.info('seekLoopWithoutCallback avPlayer from play to seek') + // play seek loop 1000 times + for(var loopTime = 0;loopTime < 1000; loopTime++){ + avPlayer.seek(loopTime) + console.info(`case seekLoopWithoutCallback loopTime is ${loopTime}`); } } await avPlayer.stop().then(() => { - console.info('avPlayerWithoutCallBack avPlayer from play to stop') + console.info('seekLoopWithoutCallback avPlayer from play to stop') avPlayer.release().then(() => { - console.info('avPlayerWithoutCallBack avPlayer from stop to release') + console.info('seekLoopWithoutCallback avPlayer from stop to release') expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); done(); }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); } +export async function prepareToStopLoop(src, avPlayer, done) { + let surfaceID = globalThis.value; + console.info(`case prepareToStopLoop Initialized in, surfaceID is ${surfaceID}`); + avPlayer = await idle(src, avPlayer) + setSource(avPlayer, src); + console.info('prepareToStopLoop setSource'); + if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { + avPlayer.surfaceId = surfaceID; + } + // prepare to stop loop 1000 times + for(var i = 0;i < 1000; i++){ + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('prepareToStopLoop avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + console.info('prepareToStopLoop avPlayer from prepare to stop') + + await avPlayer.stop().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); + console.info('prepareToStopLoop avPlayer state is stop') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + console.info(`case PrepareToStopLoop is ${i}`); + } + await avPlayer.release().then(() => { + console.info('prepareToStopLoop avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + +export async function prepareToResetLoop(src, avPlayer, done) { + let surfaceID = globalThis.value; + console.info(`case prepareToResetLoop Initialized in, surfaceID is ${surfaceID}`); + avPlayer = await idle(src, avPlayer) + // url -> prepare -> play -> reset loop 1000 times + for(var i = 0;i < 1000; i++){ + await setSource(avPlayer, src); + console.info('prepareToResetLoop setSource'); + console.info('prepareToResetLoop avPlayer state is :' + avPlayer.state) + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('prepareToResetLoop avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + await avPlayer.play().then(() => { + console.info('prepareToResetLoop play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('prepareToResetLoop play filed,error message is :' + err.message) + }) + + await avPlayer.reset().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + console.info('prepareToResetLoop avPlayer state is reset') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + console.info(`case prepareToReset loop is ${i}`); + } + + await avPlayer.release().then(() => { + console.info('prepareToResetLoop avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + +export async function createToReleaseLoop(src, avPlayer, done) { + for(var i = 0;i < 1000; i++){ + let surfaceID = globalThis.value; + console.info(`case createToReleaseLoop Initialized in, surfaceID is ${surfaceID}`); + avPlayer = await idle(src, avPlayer) + // url -> prepare -> play -> reset loop 1000 times + await setSource(avPlayer, src); + console.info('createToReleaseLoop setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('createToReleaseLoop avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + await avPlayer.play().then(() => { + console.info('createToReleaseLoop play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('createToReleaseLoop play filed,error message is :' + err.message) + }) + await avPlayer.release().then(() => { + console.info('createToReleaseLoop avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + + console.info(`case createToReleaseLoop loop is ${i}`); + } + await avPlayer.release().then(() => { + console.info('createToReleaseLoop avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + +let createLoopTime = 0; +let createTotalTime = 0; +let createStart; +export async function createTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + createStart = Date.now(); + console.info(`createTimeWithCallback createStart time is : ${createStart}`) + createTimeWithCallback(src, avPlayer, done) +} + +function createTimeCallback(src, avPlayer, done){ + let end; + let execution; + avPlayer.on('stateChange', async (state, reason) => { + console.info(`createTimeCallback stateChange called, state is ${state}, reason is ${reason}`); + console.info(`createTimeCallback state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.IDLE: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + end = Date.now(); + console.info(`createTimeCallback end time is : ${end}`) + execution = parseInt(end - createStart) + createTotalTime = createTotalTime + execution; + console.info("createTimeCallback execution time is :" + execution) + createLoopTime++; + avPlayer.release() + case AV_PLAYER_STATE.RELEASED: + console.info('createTimeCallback play state is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + if(createLoopTime == 10){ + let avg = createTotalTime/10; + console.info("createTimeCallback avg time is :" + avg) + createLoopTime = 0; + createTotalTime = 0; + done(); + }else{ + avPlayer = null; + createTimeWithCallback(src, avPlayer, done) + } + break; + default: + break; + } + }); +} + +export async function createTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + for(var i = 0;i < 10;i++){ + let start = Date.now(); + console.info(`createTimeWithoutCallback start time is : ${start}`) + avPlayer = await idle(src, avPlayer) + let end = Date.now() + let execution = parseInt(end - start) + console.info("createTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('createTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("createTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function prepareTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('prepareTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + let start = Date.now(); + console.info(`prepareTimeWithoutCallback start time is : ${start}`) + let end; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('prepareTimeWithoutCallback avPlayer state is prepared') + end = Date.now() + console.info(`prepareTimeWithoutCallback end time is : ${end}`) + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let execution = parseInt(end - start) + console.info("prepareTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('prepareTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("prepareTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function prepareTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + prepareTimeCallback(src, avPlayer, done) + await setSource(avPlayer, src); +} + +async function prepareTimeCallback(src, avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.IDLE: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('prepareTimeWithCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("prepareTimeWithCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + setSource(avPlayer, src) + } + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('prepareTimeWithCallback play state is INITIALIZED') + // step 1: initialized -> prepared + start = Date.now(); + console.info(`prepareTimeWithCallback start time is : ${start}`) + avPlayer.prepare() + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('prepareTimeWithCallback avPlayer state is prepared') + end = Date.now(); + console.info(`prepareTimeWithCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("prepareTimeWithCallback execution time is :" + execution) + totalTime = totalTime + execution; + loopTime++; + avPlayer.reset() + break; + default: + break; + } + }); +} + +export async function playTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('playTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('playTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let start = Date.now(); + let end; + console.info(`playTimeWithoutCallback start time is : ${start}`) + await avPlayer.play().then(() => { + end = Date.now(); + console.info(`playTimeWithoutCallback end time is : ${end}`) + console.info('playTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('playTimeWithoutCallback play filed,error message is :' + err.message) + }) + let execution = parseInt(end - start) + console.info("playTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('playTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("playTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function playTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + playTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +export function playTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('playTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('playTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('playTimeCallback avPlayer state is prepared') + start = Date.now(); + console.info(`playTimeCallback start time is : ${start}`) + // step 2: prapared -> play + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('playTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + end = Date.now(); + console.info(`playTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("playTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + loopTime++; + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('playTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("playTimeWithCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + avPlayer.pause() + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('playTimeWithCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + start = Date.now(); + console.info(`playTimeCallback start time is : ${start}`) + // step 3: pause -> playing loop + avPlayer.play().then(() => { + console.info('playTimeWithCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); +} + +export async function pauseTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + let execution; + let end; + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('pauseTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('pauseTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + await avPlayer.play().then(() => { + console.info('pauseTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('pauseTimeWithoutCallback play filed,error message is :' + err.message) + }) + let start = Date.now(); + + console.info(`pauseTimeWithoutCallback start time is : ${start}`) + await avPlayer.pause().then(() => { + console.info('pauseTimeWithoutCallback pause success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + end = Date.now(); + console.info(`pauseTimeWithoutCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("pauseTimeWithoutCallback execution time is :" + execution) + }, (err) => { + console.error('pauseTimeWithoutCallback pause filed,error message is :' + err.message) + }) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('pauseTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("pauseTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function pauseTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + pauseTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function pauseTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('pauseTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('pauseTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('pauseTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('pauseTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + start = Date.now(); + console.info(`pauseTimeCallback start time is : ${start}`) + avPlayer.pause(); + break; + case AV_PLAYER_STATE.PAUSED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + end = Date.now(); + console.info(`pauseTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("pauseTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + loopTime++; + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('pauseTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("pauseTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + avPlayer.play() + } + break; + default: + break; + } + }); +} + +export async function stopTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('stopTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('stopTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + await avPlayer.play().then(() => { + console.info('stopTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('stopTimeWithoutCallback play filed,error message is :' + err.message) + }) + let start = Date.now(); + console.info(`stopTimeWithoutCallback start time is : ${start}`) + let end; + await avPlayer.stop().then(() => { + end = Date.now(); + console.info(`stopTimeWithoutCallback end time is : ${end}`) + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); + console.info('stopTimeWithoutCallback avPlayer state is stop') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let execution = parseInt(end - start) + console.info("stopTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('stopTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("stopTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function stopTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + stopTimeCallback(src, avPlayer, done) + await setSource(avPlayer, src); +} + +function stopTimeCallback(src, avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.IDLE: + setSource(avPlayer, src); + break; + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('stopTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('stopTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('stopTimeCallback avPlayer state is prepared') + start = Date.now(); + console.info(`stopTimeCallback start time is : ${start}`) + loopTime++; + avPlayer.stop() + break; + case AV_PLAYER_STATE.STOPPED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); + end = Date.now(); + console.info(`stopTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("stopTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('stopTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("stopTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + avPlayer.reset() + } + break; + default: + break; + } + }); +} + +export async function resetTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('resetTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('resetTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let end; + await avPlayer.play().then(() => { + console.info('resetTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('resetTimeWithoutCallback play filed,error message is :' + err.message) + }) + let start = Date.now(); + console.info(`resetTimeWithoutCallback start time is : ${start}`) + await avPlayer.reset().then(() => { + end = Date.now(); + console.info(`resetTimeWithoutCallback end time is : ${end}`) + console.info('reset success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + }, (err) => { + console.error('reset filed,error message is :' + err.message) + }) + let execution = parseInt(end - start) + console.info("resetTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('resetTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("resetTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function resetTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + resetTimeCallback(src, avPlayer, done) + await setSource(avPlayer, src); +} + +function resetTimeCallback(src, avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.IDLE: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); + end = Date.now(); + console.info(`resetTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("resetTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + loopTime++; + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('resetTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("resetTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + setSource(avPlayer, src) + } + break; + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('resetTimeCallback play state is INITIALIZED') + start = Date.now(); + console.info(`resetTimeCallback start time is : ${start}`) + avPlayer.reset().then(() => { + console.info('reset success'); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); +} + +export async function releaseTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('releaseTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + let start = Date.now(); + console.info(`releaseTimeWithoutCallback start time is : ${start}`) + let end; + await avPlayer.release().then(() => { + console.info('releaseTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + end = Date.now(); + console.info(`releaseTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("releaseTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + } + let avg = totalTime/10; + console.info("releaseTimeWithoutCallback avg time is :" + avg) + done(); +} + +let releaseTotalTime = 0; +let releaseLoop = 0; +export async function releaseTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + releaseTimeCallback(src, avPlayer, done) + await setSource(avPlayer, src); +} + +function releaseTimeCallback(src, avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('releaseTimeCallback play state is INITIALIZED') + start = Date.now(); + console.info(`releaseTimeCallback start time is : ${start}`) + avPlayer.release() + break; + case AV_PLAYER_STATE.RELEASED: + console.info('releaseTimeCallback play state is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + end = Date.now(); + console.info(`releaseTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("releaseTimeCallback execution time is :" + execution) + releaseTotalTime = releaseTotalTime + execution; + releaseLoop++; + if(releaseLoop == 10){ + let avg = releaseTotalTime/10; + console.info("createTimeCallback avg time is :" + avg) + releaseTotalTime = 0; + releaseLoop = 0; + done(); + }else{ + avPlayer = null; + releaseTimeWithCallback(src, avPlayer, done) + } + break; + default: + break; + } + }); +} + +export function getTotalTime(releaseTotalTime){ + return releaseTotalTime; +} + +export async function seekTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('seekTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('seekTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let end; + await avPlayer.play().then(() => { + console.info('seekTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('seekTimeWithoutCallback play filed,error message is :' + err.message) + }) + let start = Date.now(); + console.info(`seekTimeWithoutCallback start time is : ${start}`) + await avPlayer.seek(100) + end = Date.now(); + console.info(`seekTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("seekTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('seekTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("seekTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function seekTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + seekTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function seekTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('seekTimeCallback play state is INITIALIZED') + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('seekTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('seekTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('seekTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + start = Date.now(); + console.info(`seekTimeCallback start time is : ${start}`) + loopTime+=20; + if(loopTime == 220){ + avPlayer.release().then(() => { + console.info('seekTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("seekTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + avPlayer.seek(loopTime) + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('seekTimeCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play().then(() => { + console.info('seekTimeCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('seekDone', async (seekDoneTime) => { + end = Date.now(); + console.info(`seekTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("seekTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`); + avPlayer.pause() + }); +} + +export async function getTrackDescriptionTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('getTrackDescriptionTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('getTrackDescriptionTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + await avPlayer.play().then(() => { + console.info('getTrackDescriptionTimeWithoutCallback play success'); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + }, (err) => { + console.error('getTrackDescriptionTimeWithoutCallback play filed,error message is :' + err.message) + }) + let arrayDescription; + let start = Date.now(); + console.info(`getTrackDescriptionTimeWithoutCallback start time is : ${start}`) + let end; + await avPlayer.getTrackDescription().then((arrList) => { + if (arrList != null) { + arrayDescription = arrList; + } else { + console.log('video getTrackDescription fail'); + } + }).catch((error) => { + console.info(`video catchCallback, error:${error}`); + }); + end = Date.now(); + console.info(`getTrackDescriptionTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("getTrackDescriptionTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('getTrackDescriptionTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("getTrackDescriptionTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function getTrackDescriptionTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + getTrackDescriptionTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function getTrackDescriptionTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + let arrayDescription; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('getTrackDescriptionTimeCallback play state is INITIALIZED') + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('getTrackDescriptionTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('getTrackDescriptionTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('getTrackDescriptionTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + start = Date.now(); + console.info(`getTrackDescriptionTimeCallback start time is : ${start}`) + if(loopTime == 10){ + avPlayer.release().then(() => { + console.info('getTrackDescriptionTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + let avg = totalTime/10; + console.info("getTrackDescriptionTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + loopTime++; + avPlayer.getTrackDescription().then((arrList) => { + if (arrList != null) { + arrayDescription = arrList; + end = Date.now(); + console.info(`getTrackDescriptionTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("getTrackDescriptionTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + + } else { + console.log('video getTrackDescription fail'); + } + }).catch((error) => { + console.info(`video catchCallback, error:${error}`); + }); + avPlayer.pause() + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('getTrackDescriptionTimeCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play().then(() => { + console.info('getTrackDescriptionTimeCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); +} + +export async function setSpeedTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('setSpeedTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setSpeedTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let start = Date.now(); + console.info(`setSpeedTimeWithoutCallback start time is : ${start}`) + await avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X); + let end = Date.now(); + console.info(`setSpeedTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("setSpeedTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('setSpeedTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("setSpeedTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function setSpeedTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + setSpeedTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function setSpeedTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('setSpeedTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('setSpeedTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setSpeedTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('setSpeedTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + if(loopTime == 10){ + avPlayer.release().then(() => { + offCallback(avPlayer, ['stateChange', 'error']); + console.info('setSpeedTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + let avg = totalTime/10; + console.info("setSpeedTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + start = Date.now(); + console.info(`setSpeedTimeCallback start time is : ${start}`) + loopTime++ + avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X); + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('setSpeedTimeCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play().then(() => { + console.info('setSpeedTimeCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('speedDone', (speed) => { + end = Date.now(); + console.info(`setSpeedTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("setSpeedTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + console.info('speedDone success,and speed value is:' + speed) + avPlayer.pause() + }); +} + +export async function setBitrateTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('setBitrateTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setBitrateTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let start = Date.now(); + console.info(`setBitrateTimeWithoutCallback start time is : ${start}`) + let bitrate = 96000 + await avPlayer.setBitrate(bitrate) + let end = Date.now(); + console.info(`setBitrateTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("setBitrateTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('setBitrateTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("setBitrateTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function setBitrateTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + playTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function setBitrateTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('setBitrateTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('setBitrateTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setBitrateTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('setBitrateTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + if(loopTime == 10){ + avPlayer.release().then(() => { + offCallback(avPlayer, ['stateChange', 'error']); + console.info('setBitrateTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + let avg = totalTime/10; + console.info("setBitrateTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + start = Date.now(); + console.info(`setBitrateTimeCallback start time is : ${start}`) + loopTime++ + let bitrate = 96000 + avPlayer.setBitrate(bitrate) + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('setBitrateTimeCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play().then(() => { + console.info('setBitrateTimeCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('bitrateDone', (bitrate) => { + end = Date.now(); + console.info(`setBitrateTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("setBitrateTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + console.info('bitrate success,and speed value is:' + bitrate) + avPlayer.pause() + }); +} + +export async function setVolumeTimeWithoutCallback(src, avPlayer, done) { + let totalTime = 0; + let surfaceID = globalThis.value; + for(var i = 0;i < 10;i++){ + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('setVolumeTimeWithoutCallback setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setVolumeTimeWithoutCallback avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + let start = Date.now(); + console.info(`setVolumeTimeWithoutCallback start time is : ${start}`) + let volume = 1.0 + avPlayer.setVolume(volume) + let end = Date.now(); + console.info(`setVolumeTimeWithoutCallback end time is : ${end}`) + let execution = parseInt(end - start) + console.info("setVolumeTimeWithoutCallback execution time is :" + execution) + totalTime = totalTime + execution; + await avPlayer.release().then(() => { + console.info('setVolumeTimeWithoutCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + } + let avg = totalTime/10; + console.info("setVolumeTimeWithoutCallback avg time is :" + avg) + done(); +} + +export async function setVolumeTimeWithCallback(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + playTimeCallback(avPlayer, done) + await setSource(avPlayer, src); +} + +function setVolumeTimeCallback(avPlayer, done) { + let surfaceID = globalThis.value; + let start; + let end; + let execution; + let loopTime = 0; + let totalTime = 0; + console.info(`case setCallback in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('setVolumeTimeCallback play state is INITIALIZED') + // step 1: initialized -> prepared + avPlayer.prepare((err) => { + if (err != null) { + console.error(`case prepare error, errMessage is ${err.message}`); + expect().assertFail(); + done(); + } else { + console.info('setVolumeTimeCallback play state is prepared') + } + }); + await sleep(2000); + break; + case AV_PLAYER_STATE.PREPARED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('setVolumeTimeCallback avPlayer state is prepared') + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('setVolumeTimeCallback play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + if(loopTime == 10){ + avPlayer.release().then(() => { + offCallback(avPlayer, ['stateChange', 'error']); + console.info('setVolumeTimeCallback avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + let avg = totalTime/10; + console.info("setVolumeTimeCallback avg time is :" + avg) + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }else{ + start = Date.now(); + console.info(`setVolumeTimeCallback start time is : ${start}`) + loopTime++ + let volume = 1.0 + avPlayer.setVolume(volume) + } + break; + case AV_PLAYER_STATE.PAUSED: + console.info('setVolumeTimeCallback play state is PAUSED') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); + avPlayer.play().then(() => { + console.info('setVolumeTimeCallback avPlayer from pause to play') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('volumeChange', (vol) => { + end = Date.now(); + console.info(`setVolumeTimeCallback end time is : ${end}`) + execution = parseInt(end - start) + console.info("setVolumeTimeCallback execution time is :" + execution) + totalTime = totalTime + execution; + console.info('volumeChange success,and new volume is :' + vol) + avPlayer.pause() + }); +} + +export async function firstFrameTime(src, avPlayer, done) { + let surfaceID = globalThis.value; + let start; + avPlayer = await idle(src, avPlayer) + await setSource(avPlayer, src); + console.info('firstFrameTime setSource'); + await sleep(20) + avPlayer.surfaceId = surfaceID; + await avPlayer.prepare().then(() => { + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); + console.info('firstFrameTime avPlayer state is prepared') + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + await avPlayer.on('startRenderFrame', () => { + console.info('startRenderFrame success') + let end = Date.now(); + console.info(`firstFrameTime end time is : ${end}`) + let execution = parseInt(end - start) + console.info("firstFrameTime execution time is :" + execution) + sleep(100) + avPlayer.release().then(() => { + offCallback(avPlayer, ['stateChange','startRenderFrame']); + console.info('firstFrameTime avPlayer is release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + avPlayer = null; + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }) + start = Date.now(); + console.info(`firstFrameTime start time is : ${start}`) + await avPlayer.play().then(() => { + console.info('firstFrameTime play success'); + }, (err) => { + console.error('firstFrameTime play filed,error message is :' + err.message) + }) +} + +export async function avPlayerWithoutCallBack(src, avPlayer, done) { + let surfaceID = globalThis.value; + console.info(`case avPlayerWithoutCallBack Initialized in, surfaceID is ${surfaceID}`); + avPlayer = await idle(src, avPlayer) + setSource(avPlayer, src); + console.info('avPlayerWithoutCallBack setSource'); + if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { + avPlayer.surfaceId = surfaceID; + preparePromise(avPlayer); + await sleep(2000); + } + if(avPlayer.state == AV_PLAYER_STATE.PREPARED){ + console.info('avPlayerWithoutCallBack avPlayer from PREPARED to play') + // play to pause loop 1000 times + for(var i = 0;i < 1000; i++){ + await playToPauseLoop(avPlayer) + console.info(`case avPlayerWithoutCallBack playToPauseLoop is ${i}`); + } + } + await avPlayer.stop().then(() => { + console.info('avPlayerWithoutCallBack avPlayer from play to stop') + avPlayer.release().then(() => { + console.info('avPlayerWithoutCallBack avPlayer from stop to release') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + done(); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); +} + +function setAVPlayerPlay(src, avPlayer, done) { + let surfaceID = globalThis.value; + console.info(`case setAVPlayerPlay in, surfaceID is ${surfaceID}`); + avPlayer.on('stateChange', async (state, reason) => { + console.info(`case stateChange called, state is ${state}, reason is ${reason}`); + console.info(`case state is ${state}`); + switch (state) { + case AV_PLAYER_STATE.INITIALIZED: + avPlayer.surfaceId = surfaceID; + console.info('setAVPlayerPlay play state is INITIALIZED') + // step 1: initialized -> prepared -> play + preparePromise(avPlayer) + await sleep(3000); + avPlayer.play() + break; + case AV_PLAYER_STATE.PLAYING: + console.info('setAVPlayerPlay play state is PLAYING') + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); + break; + case AV_PLAYER_STATE.COMPLETED: + expect(avPlayer.currentTime).assertEqual(avPlayer.duration); + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + case AV_PLAYER_STATE.RELEASED: + expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); + offCallback(avPlayer, ['stateChange', 'error']); + avPlayer = null; + done(); + break; + case AV_PLAYER_STATE.ERROR: + expect().assertFail(); + avPlayer.release().then(() => { + }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); + break; + default: + break; + } + }); + avPlayer.on('error', async (err) => { + console.error(`case error called, errMessage is ${err.message}`); + expect().assertFail(); + await avPlayer.release().then(() => { + avPlayer = null; + done(); + }); + }); +} + +export async function avPlayerPlay(src, avPlayer, done) { + avPlayer = await idle(src, avPlayer) + setAVPlayerPlay(src, avPlayer, done); + await setSource(avPlayer, src); +} + export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) { console.info(`case media source: ${src}`) await media.createAVPlayer().then((video) => { diff --git a/multimedia/media/media_js_standard/avPlayer/Test.json b/multimedia/media/media_js_standard/avPlayer/Test.json index c4567e73a0de200229413e95091bc6b58b295978..7d452df46b09bc0a02817ff377c07e45d33cc298 100644 --- a/multimedia/media/media_js_standard/avPlayer/Test.json +++ b/multimedia/media/media_js_standard/avPlayer/Test.json @@ -5,8 +5,8 @@ "test-timeout": "180000", "bundle-name": "ohos.acts.multimedia.avplayer", "module-name": "phone", - "shell-timeout": "1000000", - "testcase-timeout": 300000 + "shell-timeout": "5000000", + "testcase-timeout": 800000 }, "kits": [ { @@ -20,14 +20,59 @@ "type": "ShellKit", "run-command": [ "remount", - "mkdir /data/test" + "mkdir /data/test", + "mkdir -p /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files", + "chmod 777 -R /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone" ] }, { "type": "PushKit", "push": [ - "ActsAVPlayerTest.hap->/data/ActsAVPlayerTest.hap", - "./resource/audio/H264_AAC.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/" + "ActsAVPlayerTest.hap->/data/test/ActsAVPlayerTest.hap", + "./resource/audio/H264_AAC.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mp4/h264_mp3_128x96_30r.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/h263_aac.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/h263_mp3.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2_AAC.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2_MP3.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/h264_1280x720_30.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H263.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/h264_aac_480p_25r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/h264_mp3_480p_25r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H263_AAC.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H263_MP3.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/mpeg2_aac_720p_30r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/mpeg2_mp3_480p_25r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/mpeg4_aac_720p_30r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mpeg_ts/mpeg4_mp3_480p_25r.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/h264_320x240_60.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/h263_1408x1152_30.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/mpeg4_320x240_60.ts -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/webm/vp8_vorbis_480p_25r.webm -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/vp8_720x480_60.webm -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H264_AAC.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H264_MP3.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mkv/h263_aac_640x480_30r.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mkv/h263_mp3_176x144_25r.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2_AAC.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2_MP3.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/videoplayer/mkv/mpeg4_aac_720p_30r.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG4_MP3.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/h264_320x240_30.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/h263_1408x1152_60.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/MPEG2.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/mpeg4_320x240_60.mkv -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AAC_48000_32_1.aac -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/audio/01.mp3 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/audio/56.m4a -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/OGG_48000_1.ogg -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/vorbis_48000_32_1.wav -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/audioplayer/flac/flac_48ksr_16kbr_1ch.flac -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/hevc_320x240_60.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/H264_MP3_1s.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/", + "./resource/media/AVPlayer/h264_aac_3840_2160.mp4 -> /data/app/el2/100/base/ohos.acts.multimedia.avplayer/haps/phone/files/" ] }, { @@ -35,7 +80,8 @@ "run-command": [ "chmod 644 /data/test/*.hap", "scanner", - "param set persist.ace.testmode.enabled 1" + "param set persist.ace.testmode.enabled 1", + "setenforce 0" ] } ] diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts index 974a9fd2680f285a9d28e024020968fefaa12873..f38c165f135a4d9b2077da44b8c11a03adc01dd8 100644 --- a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts @@ -19,6 +19,7 @@ export default class MainAbility extends Ability { // Ability is creating, initialize resources for this ability console.log("[Demo] MainAbility onCreate") globalThis.abilityWant = want; + globalThis.context = this.context; } onDestroy() { diff --git a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerStabilityTest.test.js b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerStabilityTest.test.js index 5478ce63b0e80885332b9c9a9620ea3d0aed92cf..d7921c202f34b1ee91920900372716359901ece9 100644 --- a/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerStabilityTest.test.js +++ b/multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerStabilityTest.test.js @@ -14,52 +14,102 @@ */ import media from '@ohos.multimedia.media' +import fileio from '@ohos.fileio' import * as mediaTestBase from '../../../../../../MediaTestBase'; import * as AVPlayerTestBase from '../../../../../../AVPlayerTestBase.js'; -import { testAVPlayerFun, AV_PLAYER_STATE, setSource, avPlayerWithCallBack, avPlayerWithoutCallBack, - sleep } from '../../../../../../AVPlayerTestBase.js'; import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; export default function AVPlayerStabilityTest() { describe('AVPlayerStabilityTest', function () { - const VIDEO_SOURCE = 'H264_AAC.mp4'; - const AUDIO_SOURCE = '01.mp3'; - const VIDEO_NOAUDIO = 'H264_NONE.mp4' + const VIDEO_SOURCES = [ + 'H264_AAC.mp4', + 'h264_mp3_128x96_30r.mp4', + 'h263_aac.mp4', + 'h263_mp3.mp4', + 'MPEG2_AAC.mp4', + 'MPEG2_MP3.mp4', + 'h264_1280x720_30.mp4', + 'H263.mp4', + 'MPEG2.mp4', + 'h264_aac_480p_25r.ts', + 'h264_mp3_480p_25r.ts', + 'H263_AAC.ts', + 'H263_MP3.ts', + 'mpeg2_aac_720p_30r.ts', + 'mpeg2_mp3_480p_25r.ts', + 'mpeg4_aac_720p_30r.ts', + 'mpeg4_mp3_480p_25r.ts', + 'h264_320x240_60.ts', + 'h263_1408x1152_30.ts', + 'MPEG2.ts', + 'mpeg4_320x240_60.ts', + 'vp8_vorbis_480p_25r.webm', + 'vp8_720x480_60.webm', + 'H264_AAC.mkv', + 'H264_MP3.mkv', + 'h263_aac_640x480_30r.mkv', + 'h263_mp3_176x144_25r.mkv', + 'MPEG2_AAC.mkv', + 'MPEG2_MP3.mkv', + 'mpeg4_aac_720p_30r.mkv', + 'MPEG4_MP3.mkv', + 'h264_320x240_30.mkv', + 'h263_1408x1152_60.mkv', + 'MPEG2.mkv', + 'mpeg4_320x240_60.mkv', + 'AAC_48000_32_1.aac', + '01.mp3', + '56.m4a', + 'OGG_48000_1.ogg', + 'vorbis_48000_32_1.wav', + 'flac_48ksr_16kbr_1ch.flac', + 'hevc_320x240_60.mp4', + 'H264_MP3_1s.mp4', + 'h264_aac_3840_2160.mp4' + ] + let videos = []; let TAG = "[AVPlayerStabilityTest] "; let callBackSet = 0; - const PLAY_TIME = 2; let avPlayer = null; let fileDescriptor = null; - let fileDescriptor2 = null; - let fileDescriptor3 = null; - let avPlayTest1 = { - width: 0, - height: 0, - duration: -1, - }; - let avPlayTest2 = { - width: 0, - height: 0, - duration: -1, - }; - - beforeAll(async function() { + let fdHead = 'fd://'; + let fdPath = ''; + let fdNumber = 0; + let fdNumbers = [] + const PLAY_TIME = 2; + + beforeAll(async function () { console.info('beforeAll case'); - await mediaTestBase.getStageFileDescriptor(VIDEO_SOURCE).then((res) => { - fileDescriptor = res; - }); - await mediaTestBase.getStageFileDescriptor(AUDIO_SOURCE).then((res) => { - fileDescriptor2 = res; - }); - await mediaTestBase.getStageFileDescriptor(VIDEO_NOAUDIO).then((res) => { - fileDescriptor3 = res; - }); + for(var i = 0;i < VIDEO_SOURCES.length; i++){ + await getStageFdRead(VIDEO_SOURCES[i]).then((testNumber) => { + fdNumber = testNumber; + console.info(TAG + 'this fdNumber is :' + fdNumber) + fdPath = fdHead + '' + fdNumber; + fdNumbers.push(fdNumber) + videos.push(fdPath) + }) + } }) + async function getStageFdRead(pathName) { + let fdReturn; + let contextStage = globalThis.context; + let fileDir = contextStage.filesDir + console.info("case file dir is" + JSON.stringify(fileDir)); + pathName = fileDir + '/' + pathName; + console.info("case pathName is" + pathName); + await fileio.open(pathName).then((fdNumber) => { + fdReturn = fdNumber; + console.info('[fileio]case open fd success, fd is ' + fdReturn); + }) + return fdReturn; + } + + beforeEach(async function() { console.info('beforeEach case'); - await sleep(3000); + await AVPlayerTestBase.sleep(1000); }) afterEach(async function() { @@ -69,14 +119,14 @@ export default function AVPlayerStabilityTest() { }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); } console.info('afterEach case'); - await sleep(3000); + await AVPlayerTestBase.sleep(1000); }) afterAll(async function() { console.info('afterAll case'); - await mediaTestBase.closeFileDescriptor(VIDEO_SOURCE); - await mediaTestBase.closeFileDescriptor(AUDIO_SOURCE); - await mediaTestBase.closeFileDescriptor(VIDEO_NOAUDIO); + for(var i = 0;i < fdNumbers.length; i++){ + await mediaTestBase.closeFdNumber(fdNumbers[i]); + } }) /* * @@ -89,8 +139,7 @@ export default function AVPlayerStabilityTest() { */ it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0100', 0, async function (done) { console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0100 start') - avPlayTest1 = { width: 720, height: 480, duration: 10034 }; - avPlayerWithCallBack(fileDescriptor, avPlayer, avPlayTest1, PLAY_TIME, done); + AVPlayerTestBase.avPlayerWithCallBack(videos[0], avPlayer, PLAY_TIME, done); console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0100 end') }) @@ -104,9 +153,1089 @@ export default function AVPlayerStabilityTest() { */ it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0200', 0, async function (done) { console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0200 start') - avPlayTest2 = { width: 720, height: 480, duration: 10034 }; - avPlayerWithoutCallBack(fileDescriptor, avPlayer, avPlayTest2, done); + AVPlayerTestBase.avPlayerWithoutCallBack(videos[0], avPlayer, done); console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_0200 end') }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0100 + * @tc.name : 001.test play source mp4(H264_AAC) + * @tc.desc : Local Video play source (H264_AAC) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0200 + * @tc.name : 001.test play source (H264_MP3) + * @tc.desc : Local Video play source (H264_MP3) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0200 start') + AVPlayerTestBase.avPlayerPlay(videos[1], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0300 + * @tc.name : 001.test play source mp4 (H263_AAC) + * @tc.desc : Local Video play source (H263_AAC) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0300 start') + AVPlayerTestBase.avPlayerPlay(videos[2], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0400 + * @tc.name : 001.test play source (H263_MP3) + * @tc.desc : Local Video play source (H263_MP3) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0400', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0400 start') + AVPlayerTestBase.avPlayerPlay(videos[3], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0400 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0500 + * @tc.name : 001.test play source (MPEG2_AAC) + * @tc.desc : Local Video play source (MPEG2_AAC) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0500', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0500 start') + AVPlayerTestBase.avPlayerPlay(videos[4], avPlayer,done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0500 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0600 + * @tc.name : 001.test play source (MPEG2_MP3) + * @tc.desc : Local Video play source (MPEG2_MP3) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0600', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0600 start') + AVPlayerTestBase.avPlayerPlay(videos[5], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0600 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0700 + * @tc.name : 001.test play source (MPEG2_MP3) + * @tc.desc : Local Video play source (MPEG2_MP3) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0700', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0700 start') + AVPlayerTestBase.avPlayerPlay(videos[6], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0700 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0800 + * @tc.name : 001.test play source (h263.mov) + * @tc.desc : Local Video play source (h263.mov) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0800', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0800 start') + AVPlayerTestBase.avPlayerPlay(videos[7], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0800 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0900 + * @tc.name : 001.test play source (mpeg2.mkv) + * @tc.desc : Local Video play source (mpeg2.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0900', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0900 start') + AVPlayerTestBase.avPlayerPlay(videos[8], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP4_0900 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0100 + * @tc.name : 001.test play source (h264_aac.ts) + * @tc.desc : Local Video play source (h264_aac.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[9], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0200 + * @tc.name : 001.test play source (h264_mp3.ts) + * @tc.desc : Local Video play source (h264_mp3.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0200 start') + AVPlayerTestBase.avPlayerPlay(videos[10], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0300 + * @tc.name : 001.test play source (h263_aac.ts) + * @tc.desc : Local Video play source (h263_aac.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0300 start') + AVPlayerTestBase.avPlayerPlay(videos[11], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0400 + * @tc.name : 001.test play source (h263_mp3.ts) + * @tc.desc : Local Video play source (h263_mp3.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0400', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0400 start') + AVPlayerTestBase.avPlayerPlay(videos[12], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0400 end') + }) + + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0500 + * @tc.name : 001.test play source (mpeg2_aac.ts) + * @tc.desc : Local Video play source (mpeg2_aac.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0500', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0500 start') + AVPlayerTestBase.avPlayerPlay(videos[13], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0500 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0600 + * @tc.name : 001.test play source (mpeg2_mp3.ts) + * @tc.desc : Local Video play source (mpeg2_mp3.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0600', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0600 start') + AVPlayerTestBase.avPlayerPlay(videos[14], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0600 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0700 + * @tc.name : 001.test play source (mpeg4_aac.ts) + * @tc.desc : Local Video play source (mpeg4_aac.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0700', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0700 start') + AVPlayerTestBase.avPlayerPlay(videos[15], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0700 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0800 + * @tc.name : 001.test play source (mpeg4_mp3.ts) + * @tc.desc : Local Video play source (mpeg4_mp3.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0800', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0800 start') + AVPlayerTestBase.avPlayerPlay(videos[16], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0800 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0900 + * @tc.name : 001.test play source (h264.ts) + * @tc.desc : Local Video play source (h264.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0900', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0900 start') + AVPlayerTestBase.avPlayerPlay(videos[17], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_0900 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1000 + * @tc.name : 001.test play source (h263.ts) + * @tc.desc : Local Video play source (h263.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1000', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1000 start') + AVPlayerTestBase.avPlayerPlay(videos[18], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1000 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1100 + * @tc.name : 001.test play source (mpeg2.ts) + * @tc.desc : Local Video play source (mpeg2.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1100 start') + AVPlayerTestBase.avPlayerPlay(videos[19], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1200 + * @tc.name : 001.test play source (mpeg4.ts) + * @tc.desc : Local Video play source (mpeg4.ts) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1200 start') + AVPlayerTestBase.avPlayerPlay(videos[20], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_TS_1200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0100 + * @tc.name : 001.test play source (vp8_vorbis.webm) + * @tc.desc : Local Video play source (vp8_vorbis.webm) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[21], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0200 + * @tc.name : 001.test play source (vp8.webm) + * @tc.desc : Local Video play source (vp8.webm) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0200 start') + AVPlayerTestBase.avPlayerPlay(videos[22], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WEBM_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0100 + * @tc.name : 001.test play source (H264_AAC.mkv) + * @tc.desc : Local Video play source (H264_AAC.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[23], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0200 + * @tc.name : 001.test play source (H264_MP3.mkv) + * @tc.desc : Local Video play source (H264_MP3.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0200 start') + AVPlayerTestBase.avPlayerPlay(videos[24], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0300 + * @tc.name : 001.test play source (H263_AAC.mkv) + * @tc.desc : Local Video play source (H263_AAC.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0300 start') + AVPlayerTestBase.avPlayerPlay(videos[25], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0400 + * @tc.name : 001.test play source (H263_MP3.mkv) + * @tc.desc : Local Video play source (H263_MP3.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0400', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0400 start') + AVPlayerTestBase.avPlayerPlay(videos[26], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0400 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0500 + * @tc.name : 001.test play source (MPEG2_AAC.mkv) + * @tc.desc : Local Video play source (MPEG2_AAC.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0500', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0500 start') + AVPlayerTestBase.avPlayerPlay(videos[27], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0500 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0600 + * @tc.name : 001.test play source (mpeg2_mp3.mkv) + * @tc.desc : Local Video play source (mpeg2_mp3.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0600', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0600 start') + AVPlayerTestBase.avPlayerPlay(videos[28], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0600 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0700 + * @tc.name : 001.test play source (mpeg4_aac.mkv) + * @tc.desc : Local Video play source (mpeg4_aac.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0700', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0700 start') + AVPlayerTestBase.avPlayerPlay(videos[29], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0700 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0800 + * @tc.name : 001.test play source (MPEG4_MP3.mkv) + * @tc.desc : Local Video play source (MPEG4_MP3.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0800', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0800 start') + AVPlayerTestBase.avPlayerPlay(videos[30], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0800 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0900 + * @tc.name : 001.test play source (h264.mkv) + * @tc.desc : Local Video play source (h264.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0900', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0900 start') + AVPlayerTestBase.avPlayerPlay(videos[31], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_0900 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1000 + * @tc.name : 001.test play source (h263.mkv) + * @tc.desc : Local Video play source (h263.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1000', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1000 start') + AVPlayerTestBase.avPlayerPlay(videos[32], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1000 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1100 + * @tc.name : 001.test play source (MPEG2.mkv) + * @tc.desc : Local Video play source (MPEG2.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1100 start') + AVPlayerTestBase.avPlayerPlay(videos[33], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1200 + * @tc.name : 001.test play source (mpeg4.mkv) + * @tc.desc : Local Video play source (mpeg4.mkv) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1200 start') + AVPlayerTestBase.avPlayerPlay(videos[34], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MKV_1200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_AAC_0100 + * @tc.name : 001.test play source (aac_audio.aac) + * @tc.desc : Local Video play source (aac_audio.aac) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_AAC_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_AAC_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[35], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_AAC_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP3_0100 + * @tc.name : 001.test play source (MP3_AUDIO.mp3) + * @tc.desc : Local Video play source (MP3_AUDIO.mp3) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP3_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP3_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[36], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_MP3_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_M4A_0100 + * @tc.name : 001.test play source (m4a_audio.m4a) + * @tc.desc : Local Video play source (m4a_audio.m4a) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_M4A_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_M4A_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[37], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_M4A_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_OGG_0100 + * @tc.name : 001.test play source (ogg_audio.ogg) + * @tc.desc : Local Video play source (ogg_audio.ogg) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_OGG_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_OGG_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[38], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_OGG_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WAV_0100 + * @tc.name : 001.test play source (wav_audio.wav) + * @tc.desc : Local Video play source (wav_audio.wav) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WAV_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WAV_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[39], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_WAV_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_FLAC_0100 + * @tc.name : 001.test play source (flac_audio.flac) + * @tc.desc : Local Video play source (flac_audio.flac) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_FLAC_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_FLAC_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[40], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_FLAC_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0100 + * @tc.name : 001.test play source 60fps + * @tc.desc : Local Video play source + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0100 start') + AVPlayerTestBase.avPlayerPlay(videos[41], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0200 + * @tc.name : 001.test play short source 1s + * @tc.desc : Local Video play short source + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0200 start') + AVPlayerTestBase.avPlayerPlay(videos[42], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0200 end') + }) + + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0300 + * @tc.name : 001.test play source 4k + * @tc.desc : Local Video play source + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level2 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0300 start') + AVPlayerTestBase.avPlayerPlay(videos[43], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_FORMAT_SOURCE_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0100 + * @tc.name : 001.test create->release (1000 times) + * @tc.desc : Local Video play create->release (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0100 start') + AVPlayerTestBase.createToRelease(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0200 + * @tc.name : 001.test play pause loop 1000 + * @tc.desc : Local Video play to pause 1000 times + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0200 start') + AVPlayerTestBase.avPlayerWithCallBack(videos[0], avPlayer, PLAY_TIME, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0300 + * @tc.name : 001.test complete->play->seek duration (1000 times) + * @tc.desc : Local Video complete->play->seek duration (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0300 start') + AVPlayerTestBase.playToCompleted(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0400 + * @tc.name : 001.test play->seek (1000 times wait callBack) + * @tc.desc : Local Video play->seek (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0400', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0400 start') + AVPlayerTestBase.seekLoop(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0400 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0500 + * @tc.name : 001.test play->seek (1000 times do not wait callBack) + * @tc.desc : Local Video play->seek (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0500', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0500 start') + AVPlayerTestBase.seekLoopWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0500 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0600 + * @tc.name : 001.test stop -> prepare (1000 times) + * @tc.desc : Local Video test stop -> prepare (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0600', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0600 start') + AVPlayerTestBase.prepareToStopLoop(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0600 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0700 + * @tc.name : 001.test reset -> url -> preapre -> play -> reset (1000 times) + * @tc.desc : Local Video test reset -> url -> preapre -> play -> reset (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0700', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0700 start') + AVPlayerTestBase.prepareToResetLoop(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0700 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0800 + * @tc.name : 001.test release -> create-> url -> prepare -> play -> release (1000 times) + * @tc.desc : Local Video test release -> create-> url -> prepare -> play -> release (1000 times) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0800', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0800 start') + AVPlayerTestBase.createToReleaseLoop(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_STABILITY_01_0800 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0100 + * @tc.name : 001.test create time (wait callback) + * @tc.desc : Local Video test create time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ +// it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0100', 0, async function (done) { +// console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0100 start') +// AVPlayerTestBase.createTimeWithCallback(videos[0], avPlayer, done); +// console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0100 end') +// }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0110 + * @tc.name : 001.test create time (not wait callback) + * @tc.desc : Local Video test create time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0110', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0110 start') + AVPlayerTestBase.createTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0110 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0200 + * @tc.name : 001.test prepare time (not wait callback) + * @tc.desc : Local Video test prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0200 start') + AVPlayerTestBase.prepareTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0210 + * @tc.name : 001.test prepare time (not wait callback) + * @tc.desc : Local Video test prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0210', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0210 start') + AVPlayerTestBase.prepareTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0210 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0300 + * @tc.name : 001.test play time (wait callback) + * @tc.desc : Local Video test play time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0300', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0300 start') + AVPlayerTestBase.playTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0300 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0310 + * @tc.name : 001.test play time (not wait callback) + * @tc.desc : Local Video play prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0310', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0310 start') + AVPlayerTestBase.playTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0310 end') + }) + + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0300 + * @tc.name : 001.test pause time (wait callback) + * @tc.desc : Local Video test pause time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0400', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0400 start') + AVPlayerTestBase.pauseTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0400 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0410 + * @tc.name : 001.test pause time (not wait callback) + * @tc.desc : Local Video pause prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0410', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0410 start') + AVPlayerTestBase.pauseTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0410 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0500 + * @tc.name : 001.test stop time (wait callback) + * @tc.desc : Local Video test stop time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0500', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0500 start') + AVPlayerTestBase.stopTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0500 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0510 + * @tc.name : 001.test stop time (not wait callback) + * @tc.desc : Local Video stop prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0510', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0510 start') + AVPlayerTestBase.stopTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0510 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0600 + * @tc.name : 001.test reset time (wait callback) + * @tc.desc : Local Video test reset time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0600', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0600 start') + AVPlayerTestBase.resetTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0600 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0610 + * @tc.name : 001.test reset time (not wait callback) + * @tc.desc : Local Video reset prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0610', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0610 start') + AVPlayerTestBase.resetTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0610 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0700 + * @tc.name : 001.test release time (wait callback) + * @tc.desc : Local Video test release time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0700', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0700 start') + AVPlayerTestBase.releaseTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0700 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0710 + * @tc.name : 001.test release time (not wait callback) + * @tc.desc : Local Video release prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0710', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0710 start') + AVPlayerTestBase.releaseTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0710 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0800 + * @tc.name : 001.test seek time (wait callback) + * @tc.desc : Local Video test seek time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0800', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0800 start') + AVPlayerTestBase.seekTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0800 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0810 + * @tc.name : 001.test seek time (not wait callback) + * @tc.desc : Local Video seek prepare time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0810', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0810 start') + AVPlayerTestBase.seekTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0810 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0900 + * @tc.name : 001.test getTrackDescription time (wait callback) + * @tc.desc : Local Video test getTrackDescription time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0900', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0900 start') + AVPlayerTestBase.getTrackDescriptionTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0900 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0910 + * @tc.name : 001.test getTrackDescription time (not wait callback) + * @tc.desc : Local Video test getTrackDescription time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0910', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0910 start') + AVPlayerTestBase.getTrackDescriptionTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_0910 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1000 + * @tc.name : 001.test setSpeed time (wait callback) + * @tc.desc : Local Video test setSpeed time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1000', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1000 start') + AVPlayerTestBase.setSpeedTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1000 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1010 + * @tc.name : 001.test setSpeed time (not wait callback) + * @tc.desc : Local Video test setSpeed time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1010', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1010 start') + AVPlayerTestBase.setSpeedTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1010 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1100 + * @tc.name : 001.test setBitrate time (wait callback) + * @tc.desc : Local Video test setBitrate time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1100 start') + AVPlayerTestBase.setBitrateTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1100 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1110 + * @tc.name : 001.test setBitrate time (not wait callback) + * @tc.desc : Local Video test setBitrate time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1110', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1110 start') + AVPlayerTestBase.setBitrateTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1110 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1200 + * @tc.name : 001.test setVolume time (wait callback) + * @tc.desc : Local Video test setVolume time (wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1200', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1200 start') + AVPlayerTestBase.setVolumeTimeWithCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1200 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1210 + * @tc.name : 001.test setVolume time (not wait callback) + * @tc.desc : Local Video test setVolume time (not wait callback) + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1210', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1210 start') + AVPlayerTestBase.setVolumeTimeWithoutCallback(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_01_1210 end') + }) + + /* * + * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_02_0100 + * @tc.name : 001.test firstFrame time + * @tc.desc : Local Video test firstFrame time + * @tc.size : MediumTest + * @tc.type : Function test + * @tc.level : Level3 + */ + it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_02_0100', 0, async function (done) { + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_02_0100 start') + AVPlayerTestBase.firstFrameTime(videos[0], avPlayer, done); + console.info(TAG + 'SUB_MULTIMEDIA_MEDIA_AVPLAYER_PERFORMANCE_02_0100 end') + }) }) } \ No newline at end of file