Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
1 年多 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts
未验证 提交 12efaf29 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!7993 avPlayer多场景测试用例 

Merge pull request !7993 from Nicklaus/master
上级 b0ca8538 7943f81f
隐藏空白更改
内联 并排
Showing with 2875 addition and 73 deletion
multimedia/media/media_js_standard/AVPlayerTestBase.js
浏览文件 @ 12efaf29
......@@ -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) => {
......
multimedia/media/media_js_standard/avPlayer/Test.json
浏览文件 @ 12efaf29
......@@ -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"
]
}
]
......
multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/MainAbility/MainAbility.ts
浏览文件 @ 12efaf29
......@@ -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() {
......
multimedia/media/media_js_standard/avPlayer/entry/src/main/ets/test/AVPlayerStabilityTest.test.js
浏览文件 @ 12efaf29
......@@ -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
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或