diff --git a/multimedia/media/media_js_standard/videoPlayer/BUILD.gn b/multimedia/media/media_js_standard/videoPlayer/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..de6fa7b1c1bd69339d603a3a8b659c648e3a6df6
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/BUILD.gn
@@ -0,0 +1,40 @@
+# Copyright (C) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//test/xts/tools/build/suite.gni")
+
+ohos_js_hap_suite("video_player_js_hap") {
+ hap_profile = "./src/main/config.json"
+ js2abc = true
+ deps = [
+ ":video_player_js_assets",
+ ":video_player_resources",
+ ]
+
+ # shared_libraries = [
+ # "//third_party/giflib:libgif",
+ # "//third_party/libpng:libpng",
+ # ]
+ certificate_profile = "./signature/openharmony_sx.p7b"
+ hap_name = "VideoPlayerJsTest"
+
+ # part_name = "prebuilt_hap"
+ # subsystem_name = "xts"
+}
+ohos_js_assets("video_player_js_assets") {
+ source_dir = "./src/main/js/default"
+}
+ohos_resources("video_player_resources") {
+ sources = [ "./src/main/resources" ]
+ hap_profile = "./src/main/config.json"
+}
diff --git a/multimedia/media/media_js_standard/videoPlayer/Test.json b/multimedia/media/media_js_standard/videoPlayer/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..9b3dbfbc3db9746eea486cb4f58b9ae4f59c64a0
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/Test.json
@@ -0,0 +1,36 @@
+{
+ "description": "Configuration for videoplayer Tests",
+ "driver": {
+ "type": "JSUnitTest",
+ "test-timeout": "2000000",
+ "package": "ohos.acts.multimedia.video.videoplayer",
+ "shell-timeout": "60000"
+ },
+ "kits": [
+ {
+ "type": "PushKit",
+ "pre-push": [
+ ],
+ "push": [
+ "./resource/audio/01.mp4 ->/data/media/"
+ ]
+ },
+ {
+ "type": "ShellKit",
+ "run-command": [
+ "chmod -R 666 /data/media/*",
+ "setenforce 0"
+ ],
+ "teardown-command":[
+ "setenforce 1"
+ ]
+ },
+ {
+ "test-file-name": [
+ "AudioPlayerJsTest.hap"
+ ],
+ "type": "AppInstallKit",
+ "cleanup-apps": true
+ }
+ ]
+}
diff --git a/multimedia/media/media_js_standard/videoPlayer/signature/openharmony_sx.p7b b/multimedia/media/media_js_standard/videoPlayer/signature/openharmony_sx.p7b
new file mode 100644
index 0000000000000000000000000000000000000000..9be1e98fa4c0c28ca997ed660112fa16b194f0f5
Binary files /dev/null and b/multimedia/media/media_js_standard/videoPlayer/signature/openharmony_sx.p7b differ
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/config.json b/multimedia/media/media_js_standard/videoPlayer/src/main/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..12b6dc7967483ea3be7f1dfe07c6e7b119076aaf
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/config.json
@@ -0,0 +1,74 @@
+{
+ "app": {
+ "apiVersion": {
+ "compatible": 6,
+ "releaseType": "Beta1",
+ "target": 7
+ },
+ "vendor": "acts",
+ "bundleName": "ohos.acts.multimedia.video.videoplayer",
+ "version": {
+ "code": 1000000,
+ "name": "1.0.0"
+ }
+ },
+ "deviceConfig": {
+ "default": {
+ "debug": true
+ }
+ },
+ "module": {
+ "abilities": [
+ {
+ "iconId": 16777218,
+ "skills": [
+ {
+ "entities": [
+ "entity.system.home"
+ ],
+ "actions": [
+ "action.system.home"
+ ]
+ }
+ ],
+ "descriptionId": 16777217,
+ "visible": true,
+ "labelId": 16777216,
+ "icon": "$media:icon",
+ "name": "ohos.acts.multimedia.audio.audioplayer.MainAbility",
+ "description": "$string:mainability_description",
+ "label": "$string:entry_MainAbility",
+ "type": "page",
+ "homeAbility": true,
+ "launchType": "standard"
+ }
+ ],
+ "deviceType": [
+ "phone",
+ "tablet",
+ "tv",
+ "wearable"
+ ],
+ "mainAbility": "ohos.acts.multimedia.audio.audioplayer.MainAbility",
+ "distro": {
+ "moduleType": "entry",
+ "installationFree": false,
+ "deliveryWithInstall": true,
+ "moduleName": "entry"
+ },
+ "package": "ohos.acts.multimedia.audio.audioplayer",
+ "name": ".MyApplication",
+ "js": [
+ {
+ "pages": [
+ "pages/index/index"
+ ],
+ "name": "default",
+ "window": {
+ "designWidth": 720,
+ "autoDesignWidth": true
+ }
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/app.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/app.js
new file mode 100644
index 0000000000000000000000000000000000000000..e423f4bce4698ec1d7dc86c3eea3990a5e7b1085
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/app.js
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export default {
+ onCreate() {
+ console.info('AceApplication onCreate');
+ },
+ onDestroy() {
+ console.info('AceApplication onDestroy');
+ }
+};
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/en-US.json b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/en-US.json
new file mode 100644
index 0000000000000000000000000000000000000000..e63c70d978a3a53be988388c87182f81785e170c
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/en-US.json
@@ -0,0 +1,6 @@
+{
+ "strings": {
+ "hello": "Hello",
+ "world": "World"
+ }
+}
\ No newline at end of file
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/zh-CN.json b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/zh-CN.json
new file mode 100644
index 0000000000000000000000000000000000000000..de6ee5748322f44942c1b003319d8e66c837675f
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/i18n/zh-CN.json
@@ -0,0 +1,6 @@
+{
+ "strings": {
+ "hello": "您好",
+ "world": "世界"
+ }
+}
\ No newline at end of file
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.css b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.css
new file mode 100644
index 0000000000000000000000000000000000000000..5bd7567028568bd522193b2519d545ca6dcf397d
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.css
@@ -0,0 +1,46 @@
+.container {
+ flex-direction: column;
+ justify-content: center;
+ align-items: center;
+ width: 100%;
+ height: 100%;
+}
+
+.title {
+ font-size: 40px;
+ color: #000000;
+ opacity: 0.9;
+}
+
+@media screen and (device-type: tablet) and (orientation: landscape) {
+ .title {
+ font-size: 100px;
+ }
+}
+
+@media screen and (device-type: wearable) {
+ .title {
+ font-size: 28px;
+ color: #FFFFFF;
+ }
+}
+
+@media screen and (device-type: tv) {
+ .container {
+ background-image: url("/common/images/Wallpaper.png");
+ background-size: cover;
+ background-repeat: no-repeat;
+ background-position: center;
+ }
+
+ .title {
+ font-size: 100px;
+ color: #FFFFFF;
+ }
+}
+
+@media screen and (device-type: phone) and (orientation: landscape) {
+ .title {
+ font-size: 60px;
+ }
+}
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.hml b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.hml
new file mode 100644
index 0000000000000000000000000000000000000000..f64b040a5ae394dbaa5e185e1ecd4f4556b92184
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.hml
@@ -0,0 +1,5 @@
+
+
+ {{ $t('strings.hello') }} {{ title }}
+
+
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..f38efd6118993c4d1bbb4f30adeb1ad823543ad7
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/default/pages/index/index.js
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Core, ExpectExtend} from 'deccjsunit/index'
+import Fileio from '@ohos.fileio'
+
+export default {
+ data: {
+ title: ""
+ },
+ onInit() {
+ this.title = this.$t('strings.world');
+ },
+ onShow() {
+ console.info('onShow finish')
+ const core = Core.getInstance()
+ const expectExtend = new ExpectExtend({
+ 'id': 'extend'
+ })
+ core.addService('expect', expectExtend)
+ core.init()
+ const configService = core.getDefaultService('config')
+ this.timeout = 60000
+ configService.setConfig(this)
+ //this.onload()
+ require('../../../test/List.test')
+ core.execute()
+ },
+ onReady() {
+ },
+}
\ No newline at end of file
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/List.test.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/List.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..47b9d0ad6fc3a762e576ec493a70b3615bc738db
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/List.test.js
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+require('./VideoPlayerFuncPromiseTest.test.js')
+require('./VideoPlayerAPICallbackTest.test.js')
+require('./VideoPlayerFuncCallbackTest.test.js')
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerAPICallbackTest.test.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerAPICallbackTest.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc2f60dc4bef129ed19567e955cbc393d5a0a9c2
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerAPICallbackTest.test.js
@@ -0,0 +1,2021 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import media from '@ohos.multimedia.media'
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+
+describe('VideoPlayerAPICallbackTest', function () {
+ const AUDIO_SOURCE = 'file://data/media/01.mp4';
+ const PLAY_TIME = 1000;
+ const SEEK_TIME = 5000;
+ const SEEK_CLOSEST = 3;
+ const WIDTH_VALUE = 720;
+ const HEIGHT_VALUE = 480;
+ const DURATION_TIME = 10034;
+ const CREATE_EVENT = 'create';
+ const GETSURFACE_EVENT = 'getDisplaySurface';
+ const SETSURFACE_EVENT = 'setDisplaySurface';
+ const GETDESCRIPTION = 'getTrackDescription';
+ const PREPARE_EVENT = 'prepare';
+ const PLAY_EVENT = 'play';
+ const PAUSE_EVENT = 'pause';
+ const STOP_EVENT = 'stop';
+ const RESET_EVENT = 'reset';
+ const RELEASE_EVENT = 'release';
+ const SEEK_EVENT = 'seek';
+ const SEEK_MODE_EVENT = 'seekMode';
+ const SETVOLUME_EVENT = 'volume';
+ const SETSPEED_EVENT = 'speed';
+ const ERROR_EVENT = 'error';
+ const END_EVENT = 'end';
+ const VOLUME_VALUE = 1;
+ const SPEED_VALUE = 1;
+ let surfaceID = null;
+ let events = require('events');
+ let eventEmitter = new events.EventEmitter();
+
+ beforeAll(function() {
+ console.info('beforeAll case');
+ })
+
+ beforeEach(function() {
+ console.info('beforeEach case');
+ })
+
+ afterEach(function() {
+ console.info('afterEach case');
+ })
+
+ afterAll(function() {
+ console.info('afterAll case');
+ })
+
+ function sleep(time) {
+ for(let t = Date.now(); Date.now() - t <= time;);
+ }
+
+ function printfError(error, done) {
+ expect().assertFail();
+ console.info(`case error called,errMessage is ${error.message}`);
+ done();
+ }
+
+ function printfDescription(obj) {
+ let description = "";
+ for(let i in obj) {
+ let property = obj[i];
+ console.info('case key is '+ i);
+ console.info('case value is '+ property);
+ description += i + " = " + property + "\n";
+ }
+ }
+
+ function toNextStep(videoPlayer, steps, done) {
+ if (steps[0] == END_EVENT) {
+ console.info('case success!!');
+ done();
+ } else {
+ eventEmitter.emit(steps[0], videoPlayer, steps, done);
+ }
+ }
+
+ eventEmitter.on(CREATE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ media.createVideoPlayer((err, video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case createVideoPlayer success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(GETSURFACE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.getDisplaySurface((err, outSurface) => {
+ if (typeof (err) == 'undefined') {
+ surfaceID = outSurface;
+ console.info('case getDisplaySurface success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ })
+ });
+
+ eventEmitter.on(SETSURFACE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.url = AUDIO_SOURCE;
+ videoPlayer.setDisplaySurface(surfaceID, (err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ })
+ });
+
+ eventEmitter.on(PREPARE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.url = AUDIO_SOURCE;
+ videoPlayer.prepare((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(GETDESCRIPTION, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.getTrackDescription((err, arrlist) => {
+ if (typeof (err) == 'undefined') {
+ for (let i = 0; i < arrlist.length; i++) {
+ printfDescription(arrlist[i]);
+ }
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(PLAY_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.play((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play success!!');
+ sleep(PLAY_TIME);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(PAUSE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.pause((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(STOP_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.stop((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(RESET_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.reset((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(RELEASE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.release((err) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case release success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(SEEK_EVENT, (videoPlayer, steps, done) => {
+ let seekTime = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.seek(seekTime, (err, seekDoneTime) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case seek success and seekDoneTime is '+ seekDoneTime);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(SEEK_MODE_EVENT, (videoPlayer, steps, done) => {
+ let seekTime = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.seek(seekTime, SEEK_CLOSEST, (err, seekDoneTime) => {
+ if (typeof (err) == 'undefined') {
+ expect(seekDoneTime).assertEqual(SEEK_TIME);
+ console.info('case seek success and seekDoneTime is '+ seekDoneTime);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(SETVOLUME_EVENT, (videoPlayer, steps, done) => {
+ let volumeValue = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.setVolume(volumeValue, (err) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case setVolume success');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ eventEmitter.on(SETSPEED_EVENT, (videoPlayer, steps, done) => {
+ let speedValue = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.setSpeed(speedValue, (err, speedMode) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case setSpeed success and speedMode is '+ speedMode);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ if (steps[0] == ERROR_EVENT) {
+ steps.shift();
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ }
+ });
+ });
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0100
+ * @tc.name : 01.create->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0200
+ * @tc.name : 02.play->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0300
+ * @tc.name : 03.pause->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0400
+ * @tc.name : 04.stop->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ STOP_EVENT, PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0500
+ * @tc.name : 05.reset->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ RESET_EVENT, PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0600
+ * @tc.name : 06.seek->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_EVENT, SEEK_TIME, PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_MODE_EVENT, SEEK_TIME, PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0800
+ * @tc.name : 08.setvolume->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETVOLUME_EVENT, VOLUME_VALUE, PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0900
+ * @tc.name : 09.setspeed->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETSPEED_EVENT, SPEED_VALUE, PREPARE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->prepare
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, GETDESCRIPTION,
+ PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1200
+ * @tc.name : 12.prepare 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PREPARE_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PREPARE_EVENT,
+ PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0100
+ * @tc.name : 01.create->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, PLAY_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0200
+ * @tc.name : 02.prepare->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0300
+ * @tc.name : 03.pause->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0400
+ * @tc.name : 04.stop->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, PLAY_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0500
+ * @tc.name : 05.reset->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, PLAY_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0600
+ * @tc.name : 06.seek->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_MODE_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0800
+ * @tc.name : 08.setvolume->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0900
+ * @tc.name : 09.setspeed->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PLAY_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->play
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, GETDESCRIPTION, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1200
+ * @tc.name : 12.play 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PLAY_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PLAY_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0100
+ * @tc.name : 01.create->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0200
+ * @tc.name : 02.prepare->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0300
+ * @tc.name : 03.play->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0400
+ * @tc.name : 004.stop->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0500
+ * @tc.name : 05.reset->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0600
+ * @tc.name : 06.seek->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_MODE_EVENT, SEEK_TIME, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0800
+ * @tc.name : 08.setvolume->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0900
+ * @tc.name : 09.setspeed->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->pause
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, GETDESCRIPTION, PAUSE_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1200
+ * @tc.name : 12.pause 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_PAUSE_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, PAUSE_EVENT, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0100
+ * @tc.name : 001.create->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, STOP_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0200
+ * @tc.name : 02.prepare->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0300
+ * @tc.name : 03.play->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0400
+ * @tc.name : 04.pause->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0500
+ * @tc.name : 05.reset->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, STOP_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0600
+ * @tc.name : 06.seek->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_MODE_EVENT, SEEK_TIME, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0800
+ * @tc.name : 08.setvolume->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0900
+ * @tc.name : 09.setspeed->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ STOP_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->stop
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, GETDESCRIPTION, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1200
+ * @tc.name : 12.stop 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_STOP_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, STOP_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0100
+ * @tc.name : 01.create->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, STOP_EVENT, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0200
+ * @tc.name : 02.prepare->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0300
+ * @tc.name : 03.play->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0400
+ * @tc.name : 04.pause->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0500
+ * @tc.name : 05.stop->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0600
+ * @tc.name : 06.seek->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_MODE_EVENT, SEEK_TIME, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0800
+ * @tc.name : 08.setvolume->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0900
+ * @tc.name : 09.setspeed->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->reset
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, GETDESCRIPTION, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1200
+ * @tc.name : 12.reset 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RESET_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RESET_EVENT, RESET_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0100
+ * @tc.name : 01.create->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0200
+ * @tc.name : 02.prepare->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0300
+ * @tc.name : 03.play->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0400
+ * @tc.name : 04.pause->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0500
+ * @tc.name : 05.stop->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0600
+ * @tc.name : 06.seek->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0700
+ * @tc.name : 07.seek(mode)->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_MODE_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0800
+ * @tc.name : 08.setvolume->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0900
+ * @tc.name : 09.setspeed->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1000
+ * @tc.name : 10.setDisplaySurface->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1100
+ * @tc.name : 11.getTrackDescription->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, GETDESCRIPTION, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1200
+ * @tc.name : 12.reset->release
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_RELEASE_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0100
+ * @tc.name : 01.create->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, SEEK_EVENT, SEEK_TIME, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0200
+ * @tc.name : 02.prepare->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0300
+ * @tc.name : 03.play->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0400
+ * @tc.name : 04.pause->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0500
+ * @tc.name : 05.stop->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, SEEK_EVENT, SEEK_TIME, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0600
+ * @tc.name : 06.reset->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, SEEK_EVENT, SEEK_TIME, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0700
+ * @tc.name : 07.setvolume->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0800
+ * @tc.name : 08.setspeed->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE,
+ SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0900
+ * @tc.name : 09.setDisplaySurface->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ SEEK_EVENT, SEEK_TIME, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1000
+ * @tc.name : 10.getTrackDescription->seek
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, GETDESCRIPTION, SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1100
+ * @tc.name : 11.seek 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, SEEK_EVENT, SEEK_TIME,
+ SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1300
+ * @tc.name : 13.seek(-1)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, -1, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1400
+ * @tc.name : 14.seek(out of duration)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SEEK_CALLBACK_1400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, DURATION_TIME + 1000, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0100
+ * @tc.name : 01.create->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0200
+ * @tc.name : 02.prepare->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0300
+ * @tc.name : 03.play->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0400
+ * @tc.name : 04.pause->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0500
+ * @tc.name : 05.stop->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0600
+ * @tc.name : 06.reset->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0700
+ * @tc.name : 07.seek->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0800
+ * @tc.name : 08.setspeed->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, SETVOLUME_EVENT,
+ VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0900
+ * @tc.name : 09.setDisplaySurface->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ SETVOLUME_EVENT, VOLUME_VALUE, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1000
+ * @tc.name : 10.getTrackDescription->setvolume
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, GETDESCRIPTION, SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1100
+ * @tc.name : 11.setvolume 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, SETVOLUME_EVENT, VOLUME_VALUE,
+ SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1300
+ * @tc.name : 13.setvolume(<0)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, -1, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1400
+ * @tc.name : 14.setvolume(> 1)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETVOLUME_CALLBACK_1400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, 2, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0100
+ * @tc.name : 01.create->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, SETSPEED_EVENT, SPEED_VALUE,ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0200
+ * @tc.name : 02.prepare->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0300
+ * @tc.name : 03.play->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0400
+ * @tc.name : 04.pause->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, PAUSE_EVENT, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0500
+ * @tc.name : 05.stop->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, STOP_EVENT, SETSPEED_EVENT, SPEED_VALUE,
+ ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0600
+ * @tc.name : 06.reset->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RESET_EVENT, SETSPEED_EVENT, SPEED_VALUE,
+ ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0700
+ * @tc.name : 07.seek->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SEEK_EVENT, SEEK_TIME, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0800
+ * @tc.name : 08.setvolume->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, SETSPEED_EVENT,
+ SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0900
+ * @tc.name : 09.setDisplaySurface->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ SETSPEED_EVENT, SPEED_VALUE, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1000
+ * @tc.name : 10.getTrackDescription->setspeed
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, GETDESCRIPTION, SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1100
+ * @tc.name : 11.setspeed 3 times
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, SPEED_VALUE, SETSPEED_EVENT, SPEED_VALUE,
+ SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1300
+ * @tc.name : 13.setspeed(< 0)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, -1, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1400
+ * @tc.name : 14.setspeed(> 4)
+ * @tc.desc : Audio recordr control test
+ * @tc.size : MediumTest
+ * @tc.type : Function
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_SETSPEED_CALLBACK_1400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, SETSPEED_EVENT, 5, ERROR_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+})
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncCallbackTest.test.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncCallbackTest.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0acc183ce890216f687e4219b3186623b0abe1b
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncCallbackTest.test.js
@@ -0,0 +1,711 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import media from '@ohos.multimedia.media'
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+
+describe('VideoPlayerFuncCallbackTest', function () {
+ const AUDIO_SOURCE = 'file://data/media/01.mp4';
+ const PLAY_TIME = 3000;
+ const SEEK_TIME = 5000;
+ const SEEK_CLOSEST = 3;
+ const WIDTH_VALUE = 720;
+ const HEIGHT_VALUE = 480;
+ const DURATION_TIME = 10034;
+ const CREATE_EVENT = 'create';
+ const GETSURFACE_EVENT = 'getDisplaySurface';
+ const SETSURFACE_EVENT = 'setDisplaySurface';
+ const GETDESCRIPTION = 'getTrackDescription';
+ const PREPARE_EVENT = 'prepare';
+ const PLAY_EVENT = 'play';
+ const PAUSE_EVENT = 'pause';
+ const STOP_EVENT = 'stop';
+ const RESET_EVENT = 'reset';
+ const RELEASE_EVENT = 'release';
+ const SEEK_EVENT = 'seek';
+ const SEEK_MODE_EVENT = 'seekMode';
+ const SETVOLUME_EVENT = 'volume';
+ const SETSPEED_EVENT = 'speed';
+ const END_EVENT = 'end';
+ const VOLUME_VALUE = 1;
+ const SPEED_VALUE = 1;
+ const DELTA_TIME = 1000;
+ let surfaceID = null;
+ let events = require('events');
+ let eventEmitter = new events.EventEmitter();
+
+ beforeAll(function() {
+ console.info('beforeAll case');
+ })
+
+ beforeEach(function() {
+ console.info('beforeEach case');
+ })
+
+ afterEach(function() {
+ console.info('afterEach case');
+ })
+
+ afterAll(function() {
+ console.info('afterAll case');
+ })
+
+ function sleep(time) {
+ for(let t = Date.now(); Date.now() - t <= time;);
+ }
+
+ function printfError(error, done) {
+ expect().assertFail();
+ console.info(`case error called,errMessage is ${error.message}`);
+ done();
+ }
+
+ function printfDescription(obj) {
+ let description = "";
+ for(let i in obj) {
+ let property = obj[i];
+ console.info('case key is '+ i);
+ console.info('case value is '+ property);
+ description += i + " = " + property + "\n";
+ }
+ }
+
+ function toNextStep(videoPlayer, steps, done) {
+ if (steps[0] == END_EVENT) {
+ console.info('case success!!');
+ done();
+ } else {
+ eventEmitter.emit(steps[0], videoPlayer, steps, done);
+ }
+ }
+
+ function setOnCallback(videoPlayer) {
+ videoPlayer.on('playbackCompleted', () => {
+ console.info('case playbackCompleted success');
+ });
+
+ videoPlayer.on('bufferingUpdate', (infoType, value) => {
+ console.info('case bufferingUpdate success infoType is ' + infoType);
+ console.info('case bufferingUpdate success value is ' + value);
+ });
+
+ videoPlayer.on('startRenderFrame', () => {
+ console.info('case startRenderFrame success');
+ });
+
+ videoPlayer.on('videoSizeChanged', (width, height) => {
+ expect(width).assertEqual(WIDTH_VALUE);
+ expect(height).assertEqual(HEIGHT_VALUE);
+ console.info('case videoSizeChanged success width is ' + width);
+ console.info('case videoSizeChanged success height is ' + height);
+ });
+
+ videoPlayer.on('error', (error) => {
+ console.info(`case error called,errMessage is ${error.message}`);
+ });
+ }
+
+ eventEmitter.on(CREATE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ media.createVideoPlayer((err, video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ setOnCallback(videoPlayer);
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case createVideoPlayer success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(GETSURFACE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.getDisplaySurface((err, outSurface) => {
+ if (typeof (err) == 'undefined') {
+ surfaceID = outSurface;
+ console.info('case getDisplaySurface success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ })
+ });
+
+ eventEmitter.on(SETSURFACE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.url = AUDIO_SOURCE;
+ videoPlayer.setDisplaySurface(surfaceID, (err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ })
+ });
+
+ eventEmitter.on(PREPARE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.prepare((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(GETDESCRIPTION, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.getTrackDescription((err, arrlist) => {
+ if (typeof (err) == 'undefined') {
+ for (let i = 0; i < arrlist.length; i++) {
+ printfDescription(arrlist[i]);
+ }
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(PLAY_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.play((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play success!!');
+ sleep(PLAY_TIME);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(PAUSE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.pause((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(STOP_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.stop((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(RESET_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.reset((err) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(RELEASE_EVENT, (videoPlayer, steps, done) => {
+ steps.shift();
+ videoPlayer.release((err) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case release success!!');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(SEEK_EVENT, (videoPlayer, steps, done) => {
+ let seekTime = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.seek(seekTime, (err, seekDoneTime) => {
+ if (typeof (err) == 'undefined') {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case seek success and seekDoneTime is '+ seekDoneTime);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(SEEK_MODE_EVENT, (videoPlayer, steps, done) => {
+ let seekTime = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.seek(seekTime, SEEK_CLOSEST, (err, seekDoneTime) => {
+ if (typeof (err) == 'undefined') {
+ if (seekTime > DURATION_TIME) {
+ seekTime = DURATION_TIME;
+ }
+ expect(seekDoneTime).assertEqual(SEEK_TIME);
+ expect(videoPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME);
+ console.info('case seek success and seekDoneTime is '+ seekDoneTime);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(SETVOLUME_EVENT, (videoPlayer, steps, done) => {
+ let volumeValue = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.setVolume(volumeValue, (err) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case setVolume success');
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ eventEmitter.on(SETSPEED_EVENT, (videoPlayer, steps, done) => {
+ let speedValue = steps[1];
+ steps.shift();
+ steps.shift();
+ videoPlayer.setSpeed(speedValue, (err, speedMode) => {
+ if (typeof (err) == 'undefined') {
+ console.info('case setSpeed success and speedMode is '+ speedMode);
+ toNextStep(videoPlayer, steps, done);
+ } else {
+ printfError(err, done);
+ }
+ });
+ });
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0100
+ * @tc.name : 001.play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT,
+ PREPARE_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0200
+ * @tc.name : 002.pause (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT,
+ PLAY_EVENT, PAUSE_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0300
+ * @tc.name : 003.pause->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0400
+ * @tc.name : 004.stop (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT,
+ PLAY_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0500
+ * @tc.name : 005.reset (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT,
+ PLAY_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0600
+ * @tc.name : 006.seek (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0700
+ * @tc.name : 007.seek CLOSEST(callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_MODE_EVENT, SEEK_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0800
+ * @tc.name : 008.setVolume (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETVOLUME_EVENT, VOLUME_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0900
+ * @tc.name : 009.setSpeed (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETSPEED_EVENT, SPEED_VALUE, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1000
+ * @tc.name : 010.getTrackDescription (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT,
+ GETDESCRIPTION, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1200
+ * @tc.name : 012.play->pause->stop (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1300
+ * @tc.name : 013.play->pause->reset (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1400
+ * @tc.name : 014.play->pause->seek->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, SEEK_EVENT, SEEK_TIME, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1500
+ * @tc.name : 015.play->pause->seek(mode)->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, SEEK_MODE_EVENT, SEEK_TIME, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1600
+ * @tc.name : 016.play->pause->setvolume->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, SETVOLUME_EVENT, VOLUME_VALUE, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1700
+ * @tc.name : 017.play->pause->setspeed->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ PAUSE_EVENT, SETSPEED_EVENT, SPEED_VALUE, PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1800
+ * @tc.name : 018.play->stop->reset (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1800', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ STOP_EVENT, RESET_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1900
+ * @tc.name : 019.play->stop->reset->prepare->play (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_1900', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ STOP_EVENT, RESET_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT,
+ PLAY_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2000
+ * @tc.name : 020.play->seek(0)->pause->stop (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2000', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_EVENT, 0, PAUSE_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2100
+ * @tc.name : 021.play->seek(0, mode)->pause->stop (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2100', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_MODE_EVENT, 0, PAUSE_EVENT, STOP_EVENT, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2200
+ * @tc.name : 022.play->seek(duration)->finish (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2200', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_EVENT, DURATION_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2300
+ * @tc.name : 023.play->seek(duration, mode)->finish (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2300', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_MODE_EVENT, DURATION_TIME, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2400
+ * @tc.name : 024.play->seek(out of duration) (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2400', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_EVENT, DURATION_TIME + 1, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2500
+ * @tc.name : 025.play->seek(out of duration, mode) (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2500', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SEEK_MODE_EVENT, DURATION_TIME + 1, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2600
+ * @tc.name : 026. play->setvolume(0~1) (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2600', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETVOLUME_EVENT, 0, SETVOLUME_EVENT, 0.2, SETVOLUME_EVENT, 0.4, SETVOLUME_EVENT, 0.6,
+ SETVOLUME_EVENT, 0.8, SETVOLUME_EVENT, 1, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2700
+ * @tc.name : 027.play->setspeed(0~4) (callback)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_CALLBACK_2700', 0, async function (done) {
+ let videoPlayer = null;
+ let mySteps = new Array(CREATE_EVENT, GETSURFACE_EVENT, SETSURFACE_EVENT, PREPARE_EVENT, PLAY_EVENT,
+ SETSPEED_EVENT, 0, SETSPEED_EVENT, 1, SETSPEED_EVENT, 2,
+ SETSPEED_EVENT, 3, SETSPEED_EVENT, 4, RELEASE_EVENT, END_EVENT);
+ eventEmitter.emit(mySteps[0], videoPlayer, mySteps, done);
+ })
+})
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncPromiseTest.test.js b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncPromiseTest.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..d35e47e51197979a1b5f400e4581f87460e93945
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/js/test/VideoPlayerFuncPromiseTest.test.js
@@ -0,0 +1,1760 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import media from '@ohos.multimedia.media'
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
+
+describe('VideoPlayerFuncPromiseTest', function () {
+ const AUDIO_SOURCE = 'file://data/media/01.mp4';
+ const PLAY_TIME = 3000;
+ const SEEK_TIME = 5000;
+ const SEEK_CLOSEST = 3;
+ const WIDTH_VALUE = 720;
+ const HEIGHT_VALUE = 480;
+ const DURATION_TIME = 10034;
+ const DELTA_TIME = 1000;
+
+ beforeAll(function() {
+ console.info('beforeAll case');
+ })
+
+ beforeEach(function() {
+ console.info('beforeEach case');
+ })
+
+ afterEach(function() {
+ console.info('afterEach case');
+ })
+
+ afterAll(function() {
+ console.info('afterAll case');
+ })
+
+ function sleep(time) {
+ for(let t = Date.now(); Date.now() - t <= time;);
+ }
+
+ function failureCallback(error) {
+ expect().assertFail();
+ console.info(`case error called,errMessage is ${error.message}`);
+ }
+
+ function catchCallback(error) {
+ expect().assertFail();
+ console.info(`case error called,errMessage is ${error.message}`);
+ }
+
+ function printfDescription(obj) {
+ let description = "";
+ for(let i in obj) {
+ let property = obj[i];
+ console.info('case key is '+ i);
+ console.info('case value is '+ property);
+ description += i + " = " + property + "\n";
+ }
+ }
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2800
+ * @tc.name : 028.Multi-instance (16 promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2800', 0, async function (done) {
+ let arr = new Array();
+ for (let i = 0; i < 14;i++) {
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ arr[i] = video
+ console.info('case createVideoPlayer success ' + i);
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+ }
+ for (let j = 0; j < 14;j++) {
+ await arr[j].release().then(() => {
+ console.info('case release success ' + j);
+ }, failureCallback).catch(catchCallback);
+ }
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0100
+ * @tc.name : 001.play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0100', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ console.info('case createVideoPlayer success');
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ console.info('case setDisplaySurface success');
+ expect(videoPlayer.state).assertEqual('idle');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ console.info('case prepare called!!');
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ expect(videoPlayer.state).assertEqual('playing');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0200
+ * @tc.name : 002.pause (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0200', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ console.info('case setDisplaySurface success');
+ expect(videoPlayer.state).assertEqual('idle');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ console.info('case prepare called!!');
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ console.info('case play called!!');
+ expect(videoPlayer.state).assertEqual('playing');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0300
+ * @tc.name : 003.pause->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0300', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0400
+ * @tc.name : 004.stop (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0400', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0500
+ * @tc.name : 005.reset (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0500', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.reset().then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0600
+ * @tc.name : 006.seek (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0600', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(SEEK_TIME).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0700
+ * @tc.name : 007.seek CLOSEST(promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0700', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ console.info('case getDisplaySurface success and surfaceID is ' + outSurface);
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(SEEK_TIME, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(videoPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME);
+ expect(seekDoneTime).assertEqual(SEEK_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0800
+ * @tc.name : 008.setVolume (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0800', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setVolume(1).then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case setVolume called');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0900
+ * @tc.name : 009.setSpeed (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level0
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_0900', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setSpeed(2).then((speedMode) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case setSpeed called and speedMode is ' + speedMode);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1000
+ * @tc.name : 010.getTrackDescription (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1000', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ let arrayDescription = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getTrackDescription().then((arrayList) => {
+ console.info('case getTrackDescription called!!');
+ if (typeof (arrayList) != 'undefined') {
+ arrayDescription = arrayList;
+ } else {
+ console.info('case getTrackDescription is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ for (let i = 0; i < arrayDescription.length; i++) {
+ printfDescription(arrayDescription[i]);
+ }
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1100
+ * @tc.name : 011.Loop true (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1100', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ videoPlayer.loop = true;
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.loop).assertEqual(true);
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(DURATION_TIME, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(seekDoneTime).assertEqual(DURATION_TIME);
+ expect(videoPlayer.currentTime + DELTA_TIME).assertEqual(seekDoneTime + DELTA_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1200
+ * @tc.name : 012.play->pause->stop (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1200', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1300
+ * @tc.name : 013.play->pause->reset (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1300', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.reset().then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1400
+ * @tc.name : 014.play->pause->seek->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1400', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(SEEK_TIME).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1500
+ * @tc.name : 015.play->pause->seek(mode)->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1500', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(SEEK_TIME, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('paused');
+ expect(seekDoneTime).assertEqual(SEEK_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1600
+ * @tc.name : 016.play->pause->setvolume->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1600', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setVolume(1).then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case setVolume called');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1700
+ * @tc.name : 017.play->pause->setspeed->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1700', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setSpeed(2).then((speedMode) => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case setSpeed called and speedMode is ' + speedMode);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1800
+ * @tc.name : 018.play->stop->reset (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1800', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.reset().then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1900
+ * @tc.name : 019.play->stop->reset->prepare->play (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_1900', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.reset().then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case reset called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2000
+ * @tc.name : 020.play->seek(0)->pause->stop (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2000', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(0).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2100
+ * @tc.name : 021.play->seek(0, mode)->pause->stop (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2100', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(0, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(seekDoneTime).assertEqual(0);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.pause().then(() => {
+ expect(videoPlayer.state).assertEqual('paused');
+ console.info('case pause called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.stop().then(() => {
+ expect(videoPlayer.state).assertEqual('stopped');
+ console.info('case stop called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2200
+ * @tc.name : 022.play->seek(duration)->finish (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2200', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ videoPlayer.on('playbackCompleted', () => {
+ console.info('case playbackCompleted called!!');
+ expect(videoPlayer.state).assertEqual('stopped');
+ videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ done();
+ }, failureCallback).catch(catchCallback);
+ });
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(DURATION_TIME).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(videoPlayer.currentTime + DELTA_TIME).assertClose(seekDoneTime + DELTA_TIME, DELTA_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2300
+ * @tc.name : 023.play->seek(duration, mode)->finish (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level1
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2300', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ videoPlayer.on('playbackCompleted', () => {
+ console.info('case playbackCompleted called!!');
+ expect(videoPlayer.state).assertEqual('stopped');
+ videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ done();
+ }, failureCallback).catch(catchCallback);
+ });
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(DURATION_TIME, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(seekDoneTime).assertEqual(DURATION_TIME);
+ expect(videoPlayer.currentTime).assertEqual(DURATION_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, failureCallback).catch(catchCallback);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2400
+ * @tc.name : 024.play->seek(out of duration) (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2400', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ videoPlayer.on('playbackCompleted', () => {
+ console.info('case playbackCompleted called!!');
+ expect(videoPlayer.state).assertEqual('stopped');
+ videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ done();
+ }, failureCallback).catch(catchCallback);
+ });
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(DURATION_TIME + 1).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, (err) => {
+ console.info('case seek out of duration called');
+ done();
+ }).catch(catchCallback);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2500
+ * @tc.name : 025.play->seek(out of duration, mode) (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2500', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ videoPlayer.on('playbackCompleted', () => {
+ console.info('case playbackCompleted called!!');
+ expect(videoPlayer.state).assertEqual('stopped');
+ videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ done();
+ }, failureCallback).catch(catchCallback);
+ });
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.seek(DURATION_TIME + 1, SEEK_CLOSEST).then((seekDoneTime) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ expect(videoPlayer.currentTime).assertEqual(DURATION_TIME);
+ console.info('case seek called and seekDoneTime is' + seekDoneTime);
+ }, (err) => {
+ console.info('case seek out of duration called');
+ done();
+ }).catch(catchCallback);
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2600
+ * @tc.name : 026. play->setvolume(0~1) (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2600', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ for (let i = 0; i < 6; i++) {
+ await videoPlayer.setVolume(i * 0.2).then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case setVolume called');
+ }, failureCallback).catch(catchCallback);
+ }
+
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+
+ /* *
+ * @tc.number : SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2700
+ * @tc.name : 028.play->setspeed(0~4) (promise)
+ * @tc.desc : Audio playback control test
+ * @tc.size : MediumTest
+ * @tc.type : Function test
+ * @tc.level : Level2
+ */
+ it('SUB_MEDIA_VIDEO_PLAYER_FUNCTION_PROMISE_2700', 0, async function (done) {
+ let videoPlayer = null;
+ let surfaceID = null;
+ await media.createVideoPlayer().then((video) => {
+ if (typeof (video) != 'undefined') {
+ videoPlayer = video;
+ expect(videoPlayer.state).assertEqual('idle');
+ } else {
+ console.info('case createVideoPlayer is failed');
+ expect().assertFail();
+ }
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.getDisplaySurface().then((outSurface) => {
+ videoPlayer.url = AUDIO_SOURCE;
+ surfaceID = outSurface;
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.setDisplaySurface(surfaceID).then(() => {
+ expect(videoPlayer.state).assertEqual('idle');
+ console.info('case setDisplaySurface success');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.prepare().then(() => {
+ expect(videoPlayer.state).assertEqual('prepared');
+ expect(videoPlayer.duration).assertEqual(DURATION_TIME);
+ expect(videoPlayer.width).assertEqual(WIDTH_VALUE);
+ expect(videoPlayer.height).assertEqual(HEIGHT_VALUE);
+ console.info('case prepare called!!');
+ }, failureCallback).catch(catchCallback);
+
+ await videoPlayer.play().then(() => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case play called!!');
+ sleep(PLAY_TIME);
+ }, failureCallback).catch(catchCallback);
+
+ for (let i = 0; i < 5; i++) {
+ await videoPlayer.setSpeed(i).then((speedMode) => {
+ expect(videoPlayer.state).assertEqual('playing');
+ console.info('case setSpeed called and speedMode is ' + speedMode);
+ }, failureCallback).catch(catchCallback);
+ }
+ await videoPlayer.release().then(() => {
+ console.info('case release called!!');
+ }, failureCallback).catch(catchCallback);
+ done();
+ })
+})
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/element/string.json b/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/element/string.json
new file mode 100644
index 0000000000000000000000000000000000000000..0bae6bd40f7360d5d818998221b199d3ec0f69c0
--- /dev/null
+++ b/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/element/string.json
@@ -0,0 +1,12 @@
+{
+ "string": [
+ {
+ "name": "entry_MainAbility",
+ "value": "entry_MainAbility"
+ },
+ {
+ "name": "mainability_description",
+ "value": "JS_Empty Ability"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/media/icon.png b/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/media/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c
Binary files /dev/null and b/multimedia/media/media_js_standard/videoPlayer/src/main/resources/base/media/icon.png differ