Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
接近 2 年 前同步成功

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

!5908 【媒体子系统】删除camera无关用例 

Merge pull request !5908 from liuxueqi/master
上级 119f5fb2 bad4ee34
显示空白变更内容
内联 并排
Showing with 12 addition and 21325 deletion
multimedia/camera/camera_js_standard/Test.json
浏览文件 @ 4abbc946
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
"description": "Configuration for camerastandard Tests", "description": "Configuration for camerastandard Tests",
"driver": { "driver": {
"type": "JSUnitTest", "type": "JSUnitTest",
"test-timeout": "1000000", "test-timeout": "2000000",
"package": "com.open.harmony.multimedia.cameratest", "package": "com.open.harmony.multimedia.cameratest",
"shell-timeout": "60000" "shell-timeout": "60000"
}, },
......
multimedia/camera/camera_js_standard/src/main/config.json
浏览文件 @ 4abbc946
...@@ -78,8 +78,16 @@ ...@@ -78,8 +78,16 @@
"reason": "use ohos.permission.READ_MEDIA" "reason": "use ohos.permission.READ_MEDIA"
}, },
{ {
"name": "ohos.permission.WRITE_MEDIA", "name": "ohos.permission.START_ABILITIES_FROM_BACKGROUND",
"reason": "use ohos.permission.WRITE_MEDIA" "reason": "use ohos.permission.START_ABILITIES_FROM_BACKGROUND"
},
{
"name": "ohos.permission.START_INVISIBLE_ABILITY",
"reason": "use ohos.permission.START_INVISIBLE_ABILITY"
},
{
"name": "ohos.permission.ABILITY_BACKGROUND_COMMUNICATION",
"reason": "use ohos.permission.ABILITY_BACKGROUND_COMMUNICATION"
} }
], ],
"js": [ "js": [
......
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/pages/index.ets
浏览文件 @ 4abbc946
...@@ -57,6 +57,7 @@ struct CameraIndex { ...@@ -57,6 +57,7 @@ struct CameraIndex {
console.info(TAG + 'Entering core.init()') console.info(TAG + 'Entering core.init()')
console.info(TAG + 'Entering subscribeEvent') console.info(TAG + 'Entering subscribeEvent')
const configService = core.getDefaultService('config') const configService = core.getDefaultService('config')
Want.parameters['timeout'] = 60000
configService.setConfig(Want.parameters) configService.setConfig(Want.parameters)
console.info(TAG + 'Entering configService') console.info(TAG + 'Entering configService')
cameraKit(surfaceId) cameraKit(surfaceId)
......
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/test/CameraJSUnitEnum.test.ets 已删除 100644 → 0
浏览文件 @ 119f5fb2
/*
* Copyright (C) 2022 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 cameraObj from '@ohos.multimedia.camera';
import image from '@ohos.multimedia.image';
import fileio from '@ohos.fileio';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
import bundle from '@ohos.bundle'
import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index';
const TAG = "CameraModuleTest: ";
// Define global variables
var cameraManager;
var surfaceId1;
var camerasArray;
// CAMERA-0 Variables
var camera0Input, camera0InputPosBack, camera0InputPosFront;
var camera0InputPromise, camera0InputPromisePosBack, camera0InputPromisePosFront;
// CAMERA-1 Variables
var camera1Input, camera1InputPosBack, camera1InputPosFront;
var camera1InputPromise, camera1InputPromisePosBack, camera1InputPromisePosFront;
// CAMERA-2 Variables
var camera2Input, camera2InputPosBack, camera2InputPosFront;
var camera2InputPromise, camera2InputPromisePosBack, camera2InputPromisePosFront;
// CAMERA-3 Variables
var camera3Input, camera3InputPosBack, camera3InputPosFront;
var camera3InputPromise, camera3InputPromisePosBack, camera3InputPromisePosFront;
export default function cameraJSUnitEnum(surfaceId: any) {
async function getImageReceiverSurfaceId() {
console.log(TAG + 'Entering create Image receiver')
var receiver = image.createImageReceiver(640, 480, 4, 8)
console.log(TAG + 'before receiver check')
if (receiver !== undefined) {
console.log(TAG + 'Receiver is ok')
surfaceId1 = await receiver.getReceivingSurfaceId()
console.log(TAG + 'Received id: ' + JSON.stringify(surfaceId1))
} else {
console.log(TAG + 'Receiver is not ok')
}
}
function sleep(ms) {
console.info(TAG + "Entering sleep -> Promise constructor");
return new Promise(resolve => setTimeout(resolve, ms));
}
async function applyPermission() {
let appInfo = await bundle.getApplicationInfo('com.open.harmony.multimedia.cameratest', 0, 100);
let atManager = abilityAccessCtrl.createAtManager();
if (atManager != null) {
let tokenID = appInfo.accessTokenId;
console.info('[permission] case accessTokenID is ' + tokenID);
let permissionName1 = 'ohos.permission.CAMERA';
let permissionName2 = 'ohos.permission.MICROPHONE';
let permissionName3 = 'ohos.permission.MEDIA_LOCATION';
let permissionName4 = 'ohos.permission.READ_MEDIA';
let permissionName5 = 'ohos.permission.WRITE_MEDIA';
await atManager.grantUserGrantedPermission(tokenID, permissionName1, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName2, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName3, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName4, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName5, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
} else {
console.info('[permission] case apply permission failed, createAtManager failed');
}
}
describe('CameraJSUnitEnum', function () {
console.info(TAG + '----------CameraJSUnitEnum--------------')
beforeAll(async function () {
await applyPermission();
console.info('beforeAll case');
})
beforeEach(function () {
sleep(5000);
console.info('beforeEach case');
})
afterEach(async function () {
console.info('afterEach case');
})
afterAll(function () {
console.info('afterAll case');
})
/**
* @tc.number : GET_CAMERA_MANAGER_TC_001
* @tc.name : Create camera manager instance async api
* @tc.desc : Create camera manager instance async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERA_MANAGER_TC_001', 0, async function (done) {
console.info("--------------GET_CAMERA_MANAGER_TC_001--------------");
cameraObj.getCameraManager(null, async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_CAMERA_MANAGER_TC_001 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering GET_CAMERA_MANAGER_TC_001 data is not null || undefined");
cameraManager = data;
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERA_MANAGER_TC_001 PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERA_MANAGER_TC_001 FAILED: " + err.message);
}
console.info(TAG + "Entering GET_CAMERA_MANAGER_TC_001 ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_CAMERAS_TC_002
* @tc.name : Get camera from cameramanager to get array of camera async api
* @tc.desc : Get camera from cameramanager to get array of camera async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERAS_TC_002', 0, async function (done) {
console.info("--------------GET_CAMERAS_TC_002--------------");
cameraManager.getCameras(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_CAMERAS_TC_002 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering GET_CAMERAS_TC_002 data is not null || undefined");
camerasArray = data;
if (camerasArray != null && camerasArray.length > 0) {
for (var i = 0; i < camerasArray.length; i++) {
// Get the variables from camera object
var cameraId = camerasArray[i].cameraId;
console.info(TAG + "Entering GET_CAMERAS_TC_002 camera" + i + "Id: " + cameraId);
var cameraPosition = camerasArray[i].cameraPosition;
console.info(TAG + "Entering GET_CAMERAS_TC_002 camera" + i + "Position: " + cameraPosition);
var cameraType = camerasArray[i].cameraType;
console.info(TAG + "Entering GET_CAMERAS_TC_002 camera" + i + "Type: " + cameraType);
var connectionType = camerasArray[i].connectionType
console.info(TAG + "Entering GET_CAMERAS_TC_002 connection" + i + "Type: " + connectionType);
}
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERAS_TC_002 PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERAS_TC_002 FAILED cameraArray is null || undefined");
}
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERAS_TC_002 FAILED: " + err.message);
}
console.info(TAG + "Entering GET_CAMERAS_TC_002 ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/*CAMERA-0 Scripts*/
/**
* @tc.number : CREATE_CAMERA_INPUT_TC_003
* @tc.name : Create camerainput from camera-0 cameraId async api
* @tc.desc : Create camerainput from camera-0 cameraId async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT_TC_003', 0, async function (done) {
console.info("--------------CAMERA-0 STARTS HERE--------------");
console.info("--------------CREATE_CAMERA_INPUT_TC_003--------------");
cameraManager.createCameraInput(camerasArray[0].cameraId, async (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + "Entering CREATE_CAMERA_INPUT_TC_003 data is not null || undefined");
camera0Input = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_TC_003 PASSED with CameraID :" + camerasArray[0].cameraId);
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_TC_003 FAILED: " + err.message);
}
console.info(TAG + "Entering CREATE_CAMERA_INPUT_TC_003 ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_STATUS
* @tc.name : camera status ENAME
* @tc.desc : camera status ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_STATUS', 0, async function (done) {
console.info(TAG + "--------------CameraStatus ------------");
console.info(TAG + "CameraStatus CAMERA_STATUS_APPEAR : " + cameraObj.CameraStatus.CAMERA_STATUS_APPEAR);
expect(cameraObj.CameraStatus.CAMERA_STATUS_APPEAR).assertEqual(0);
console.info(TAG + "CameraStatus CAMERA_STATUS_DISAPPEAR : " + cameraObj.CameraStatus.CAMERA_STATUS_DISAPPEAR);
expect(cameraObj.CameraStatus.CAMERA_STATUS_DISAPPEAR).assertEqual(1);
console.info(TAG + "CameraStatus CAMERA_STATUS_AVAILABLE : " + cameraObj.CameraStatus.CAMERA_STATUS_AVAILABLE)
expect(cameraObj.CameraStatus.CAMERA_STATUS_AVAILABLE).assertEqual(2);
console.info(TAG + "CameraStatus CAMERA_STATUS_UNAVAILABLE : " + cameraObj.CameraStatus.CAMERA_STATUS_UNAVAILABLE)
expect(cameraObj.CameraStatus.CAMERA_STATUS_UNAVAILABLE).assertEqual(3);
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_POSITION
* @tc.name : Camera position ENAME
* @tc.desc : Camera position ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_POSITION', 0, async function (done) {
console.info(TAG + "--------------CameraPosition ------------")
console.info(TAG + "CameraPosition CAMERA_POSITION_BACK : " + cameraObj.CameraPosition.CAMERA_POSITION_BACK);
expect(cameraObj.CameraPosition.CAMERA_POSITION_BACK).assertEqual(1);
console.info(TAG + "CameraPosition CAMERA_POSITION_FRONT : " + cameraObj.CameraPosition.CAMERA_POSITION_FRONT);
expect(cameraObj.CameraPosition.CAMERA_POSITION_FRONT).assertEqual(2);
console.info(TAG + "CameraPosition CAMERA_POSITION_UNSPECIFIED : " + cameraObj.CameraPosition.CAMERA_POSITION_UNSPECIFIED);
expect(cameraObj.CameraPosition.CAMERA_POSITION_UNSPECIFIED).assertEqual(0);
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_TYPE
* @tc.name : camera type ENAME
* @tc.desc : camera type ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_TYPE', 0, async function (done) {
console.info(TAG + "--------------CameraType ------------")
console.info(TAG + "CameraType CAMERA_TYPE_UNSPECIFIED : " + cameraObj.CameraType.CAMERA_TYPE_UNSPECIFIED);
expect(cameraObj.CameraType.CAMERA_TYPE_UNSPECIFIED).assertEqual(0);
console.info(TAG + "CameraType CAMERA_TYPE_WIDE_ANGLE : " + cameraObj.CameraType.CAMERA_TYPE_WIDE_ANGLE);
expect(cameraObj.CameraType.CAMERA_TYPE_WIDE_ANGLE).assertEqual(1);
console.info(TAG + 'CameraType CAMERA_TYPE_ULTRA_WIDE : ' + cameraObj.CameraType.CAMERA_TYPE_ULTRA_WIDE);
expect(cameraObj.CameraType.CAMERA_TYPE_ULTRA_WIDE).assertEqual(2);
console.info(TAG + 'CameraType CAMERA_TYPE_TELEPHOTO : ' + cameraObj.CameraType.CAMERA_TYPE_TELEPHOTO);
expect(cameraObj.CameraType.CAMERA_TYPE_TELEPHOTO).assertEqual(3);
console.info(TAG + 'CameraType CAMERA_TYPE_TRUE_DEPTH : ' + cameraObj.CameraType.CAMERA_TYPE_TRUE_DEPTH)
expect(cameraObj.CameraType.CAMERA_TYPE_TRUE_DEPTH).assertEqual(4);
await sleep(1000);
done();
})
/**
* @tc.number : CONNECTION_TYPE
* @tc.name : connection type ENAME
* @tc.desc : connection type ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CONNECTION_TYPE', 0, async function (done) {
console.info(TAG + "--------------ConnectionType ------------")
console.info(TAG + "ConnectionType CAMERA_CONNECTION_BUILT_IN : " + cameraObj.ConnectionType.CAMERA_CONNECTION_BUILT_IN);
expect(cameraObj.ConnectionType.CAMERA_CONNECTION_BUILT_IN).assertEqual(0);
console.info(TAG + "ConnectionType CAMERA_CONNECTION_USB_PLUGIN : " + cameraObj.ConnectionType.CAMERA_CONNECTION_USB_PLUGIN);
expect(cameraObj.ConnectionType.CAMERA_CONNECTION_USB_PLUGIN).assertEqual(1);
console.info(TAG + "ConnectionType CAMERA_CONNECTION_REMOTE : " + cameraObj.ConnectionType.CAMERA_CONNECTION_REMOTE);
expect(cameraObj.ConnectionType.CAMERA_CONNECTION_REMOTE).assertEqual(2);
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_FORMAT
* @tc.name : Camera Format ENAME
* @tc.desc : Camera Format ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* CameraFormat Interface will be change
it('CAMERA_FORMAT', 0, async function (done) {
console.info(TAG + "--------------CameraFormat ------------")
console.info(TAG + "CameraFormat CAMERA_FORMAT_YUV_420_SP : " + cameraObj.CameraFormat.CAMERA_FORMAT_YUV_420_SP);
expect(cameraObj.CameraFormat.CAMERA_FORMAT_YUV_420_SP).assertEqual(1003);
console.info(TAG + "CameraFormat CAMERA_FORMAT_JPEG : " + cameraObj.CameraFormat.CAMERA_FORMAT_JPEG);
expect(cameraObj.CameraFormat.CAMERA_FORMAT_JPEG).assertEqual(2000);
await sleep(1000);
done();
})
*/
/**
* @tc.number : FLASHMODE
* @tc.name : Flash Mode ENAME
* @tc.desc : Flash Mode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FLASHMODE', 0, async function (done) {
console.info(TAG + "--------------FlashMode ------------")
console.info(TAG + "FlashMode FLASH_MODE_CLOSE : " + cameraObj.FlashMode.FLASH_MODE_CLOSE);
expect(cameraObj.FlashMode.FLASH_MODE_CLOSE).assertEqual(0);
console.info(TAG + "FlashMode FLASH_MODE_OPEN : " + cameraObj.FlashMode.FLASH_MODE_OPEN);
expect(cameraObj.FlashMode.FLASH_MODE_OPEN).assertEqual(1);
console.info(TAG + "FlashMode FLASH_MODE_AUTO : " + cameraObj.FlashMode.FLASH_MODE_AUTO);
expect(cameraObj.FlashMode.FLASH_MODE_AUTO).assertEqual(2);
console.info(TAG + "FlashMode FLASH_MODE_ALWAYS_OPEN : " + cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
expect(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN).assertEqual(3);
await sleep(1000);
done();
})
/**
* @tc.number : FOCUSMODE
* @tc.name : Focus Mode ENAME
* @tc.desc : Focus Mode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSMODE', 0, async function (done) {
console.info(TAG + "--------------FocusMode ------------")
console.info(TAG + "FocusMode FOCUS_MODE_MANUAL : " + cameraObj.FocusMode.FOCUS_MODE_MANUAL);
expect(cameraObj.FocusMode.FOCUS_MODE_MANUAL).assertEqual(0);
console.info(TAG + "FocusMode FOCUS_MODE_CONTINUOUS_AUTO : " + cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
expect(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO).assertEqual(1);
console.info(TAG + "FocusMode FOCUS_MODE_AUTO : " + cameraObj.FocusMode.FOCUS_MODE_AUTO);
expect(cameraObj.FocusMode.FOCUS_MODE_AUTO).assertEqual(2);
console.info(TAG + "FocusMode FOCUS_MODE_LOCKED : " + cameraObj.FocusMode.FOCUS_MODE_LOCKED);
expect(cameraObj.FocusMode.FOCUS_MODE_LOCKED).assertEqual(3);
await sleep(1000);
done();
})
/**
* @tc.number : FOCUSSTATE
* @tc.name : Focus State ENAME
* @tc.desc : Focus State ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSSTATE', 0, async function (done) {
console.info(TAG + "--------------FocusState ------------")
console.info(TAG + "FocusState FOCUS_STATE_SCAN : " + cameraObj.FocusState.FOCUS_STATE_SCAN);
expect(cameraObj.FocusState.FOCUS_STATE_SCAN).assertEqual(0);
console.info(TAG + "FocusState FOCUS_STATE_FOCUSED : " + cameraObj.FocusState.FOCUS_STATE_FOCUSED);
expect(cameraObj.FocusState.FOCUS_STATE_FOCUSED).assertEqual(1);
console.info(TAG + "FocusState FOCUS_STATE_UNFOCUSED : " + cameraObj.FocusState.FOCUS_STATE_UNFOCUSED);
expect(cameraObj.FocusState.FOCUS_STATE_UNFOCUSED).assertEqual(2);
await sleep(1000);
done();
})
/**
* @tc.number : EXPOSUREMODE
* @tc.name : Exposure Mode ENAME
* @tc.desc : Exposure Mode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('EXPOSUREMODE', 0, async function (done) {
console.info(TAG + "--------------ExposureMode ------------")
console.info(TAG + "ExposureMode EXPOSURE_MODE_LOCKED : " + cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED);
expect(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED).assertEqual(0);
console.info(TAG + "ExposureMode EXPOSURE_MODE_AUTO : " + cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
expect(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO).assertEqual(1);
console.info(TAG + "ExposureMode EXPOSURE_MODE_CONTINUOUS_AUTO : " + cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO);
expect(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO).assertEqual(2);
await sleep(1000);
done();
})
*/
/**
* @tc.number : ExposureState
* @tc.name : Exposure State ENAME
* @tc.desc : Exposure State ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* ExposureState Interface will be change
it('ExposureState', 0, async function (done) {
console.info(TAG + "--------------ExposureState ------------")
console.info(TAG + "ExposureState EXPOSURE_STATE_SCAN : " + cameraObj.ExposureState.EXPOSURE_STATE_SCAN);
expect(cameraObj.ExposureState.EXPOSURE_STATE_SCAN).assertEqual(0);
console.info(TAG + "ExposureState EXPOSURE_STATE_CONVERGED : " + cameraObj.ExposureState.EXPOSURE_STATE_CONVERGED);
expect(cameraObj.ExposureState.EXPOSURE_STATE_CONVERGED).assertEqual(1);
await sleep(1000);
done();
})
*/
/**
* @tc.number : ImageRotation
* @tc.name : Image Rotation ENAME
* @tc.desc : Image Rotation ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ImageRotation', 0, async function (done) {
console.info(TAG + "--------------ImageRotation ------------")
console.info(TAG + "ImageRotation ROTATION_0 : " + cameraObj.ImageRotation.ROTATION_0);
expect(cameraObj.ImageRotation.ROTATION_0).assertEqual(0);
console.info(TAG + "ImageRotation ROTATION_90 : " + cameraObj.ImageRotation.ROTATION_90);
expect(cameraObj.ImageRotation.ROTATION_90).assertEqual(90);
console.info(TAG + "ImageRotation ROTATION_180 : " + cameraObj.ImageRotation.ROTATION_180);
expect(cameraObj.ImageRotation.ROTATION_180).assertEqual(180);
console.info(TAG + "ImageRotation ROTATION_270 : " + cameraObj.ImageRotation.ROTATION_270);
expect(cameraObj.ImageRotation.ROTATION_270).assertEqual(270);
await sleep(1000);
done();
})
/**
* @tc.number : QualityLevel
* @tc.name : Quality Level ENAME
* @tc.desc : Quality Level ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('QualityLevel', 0, async function (done) {
console.info(TAG + "--------------QualityLevel ------------")
console.info(TAG + "QualityLevel QUALITY_LEVEL_HIGH : " + cameraObj.QualityLevel.QUALITY_LEVEL_HIGH);
expect(cameraObj.QualityLevel.QUALITY_LEVEL_HIGH).assertEqual(0);
console.info(TAG + "QualityLevel QUALITY_LEVEL_MEDIUM : " + cameraObj.QualityLevel.QUALITY_LEVEL_MEDIUM);
expect(cameraObj.QualityLevel.QUALITY_LEVEL_MEDIUM).assertEqual(1);
console.info(TAG + "QualityLevel QUALITY_LEVEL_LOW : " + cameraObj.QualityLevel.QUALITY_LEVEL_LOW);
expect(cameraObj.QualityLevel.QUALITY_LEVEL_LOW).assertEqual(2);
await sleep(1000);
done();
})
/**
* @tc.number : VIDEOSTABILIZATION_ENUM
* @tc.name : VIDEOSTABILIZATION ENAME
* @tc.desc : VIDEOSTABILIZATION ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('VideoStabilization', 0, async function (done) {
console.info(TAG + "--------------VideoStabilization ------------")
console.info(TAG + "VideoStabilization OFF : " + cameraObj.VideoStabilizationMode.OFF);
expect(cameraObj.VideoStabilizationMode.OFF).assertEqual(0);
console.info(TAG + "VideoStabilization LOW : " + cameraObj.VideoStabilizationMode.LOW);
expect(cameraObj.VideoStabilizationMode.LOW).assertEqual(1);
console.info(TAG + "VideoStabilization MIDDLE : " + cameraObj.VideoStabilizationMode.MIDDLE);
expect(cameraObj.VideoStabilizationMode.MIDDLE).assertEqual(2);
console.info(TAG + "VideoStabilization HIGH : " + cameraObj.VideoStabilizationMode.HIGH);
expect(cameraObj.VideoStabilizationMode.HIGH).assertEqual(3);
console.info(TAG + "VideoStabilization AUTO : " + cameraObj.VideoStabilizationMode.AUTO);
expect(cameraObj.VideoStabilizationMode.AUTO).assertEqual(4);
await sleep(1000);
done();
})
*/
})
/**
* @tc.number : SUB_MULTIMEDIA_CAMERAINPUTERRORCODE_0100
* @tc.name : CameraInputErrorCode ENAME
* @tc.desc : CameraInputErrorCode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_MULTIMEDIA_CAMERAINPUTERRORCODE_0100', 0, async function (done) {
console.info(TAG + "--------------SUB_MULTIMEDIA_CAMERAINPUTERRORCODE_0100------------")
console.info(TAG + "QualityLevel SUB_MULTIMEDIA_CAMERAINPUTERRORCODE_0100 : " + cameraObj.CameraInputErrorCode.ERROR_UNKNOWN);
expect(cameraObj.CameraInputErrorCode.ERROR_UNKNOWN).assertEqual(-1);
await sleep(1000);
done();
})
/**
* @tc.number : SUB_MULTIMEDIA_CAPTURESESSIONERRORCODE_0100
* @tc.name : CaptureSessionErrorCode ENAME
* @tc.desc : CaptureSessionErrorCode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_MULTIMEDIA_CAPTURESESSIONERRORCODE_0100', 0, async function (done) {
console.info(TAG + "--------------SUB_MULTIMEDIA_CAPTURESESSIONERRORCODE_0100------------")
console.info(TAG + "QualityLevel SUB_MULTIMEDIA_CAPTURESESSIONERRORCODE_0100 : " + cameraObj.CaptureSessionErrorCode.ERROR_UNKNOWN);
expect(cameraObj.CaptureSessionErrorCode.ERROR_UNKNOWN).assertEqual(-1);
await sleep(1000);
done();
})
/**
* @tc.number : SUB_MULTIMEDIA_PREVIEWOUTPUTERRORCODE_0100
* @tc.name : PreviewOutputErrorCode ENAME
* @tc.desc : PreviewOutputErrorCode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_MULTIMEDIA_PREVIEWOUTPUTERRORCODE_0100', 0, async function (done) {
console.info(TAG + "--------------SUB_MULTIMEDIA_PREVIEWOUTPUTERRORCODE_0100------------")
console.info(TAG + "QualityLevel SUB_MULTIMEDIA_PREVIEWOUTPUTERRORCODE_0100 : " + cameraObj.PreviewOutputErrorCode.ERROR_UNKNOWN);
expect(cameraObj.PreviewOutputErrorCode.ERROR_UNKNOWN).assertEqual(-1);
await sleep(1000);
done();
})
/**
* @tc.number : SUB_MULTIMEDIA_PHOTOOUTPUTERRORCODE_0100
* @tc.name : PhotoOutputErrorCode ENAME
* @tc.desc : PhotoOutputErrorCode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_MULTIMEDIA_PHOTOOUTPUTERRORCODE_0100', 0, async function (done) {
console.info(TAG + "--------------SUB_MULTIMEDIA_PHOTOOUTPUTERRORCODE_0100------------")
console.info(TAG + "QualityLevel SUB_MULTIMEDIA_PHOTOOUTPUTERRORCODE_0100 : " + cameraObj.PhotoOutputErrorCode.ERROR_UNKNOWN);
expect(cameraObj.PhotoOutputErrorCode.ERROR_UNKNOWN).assertEqual(-1);
await sleep(1000);
done();
})
/**
* @tc.number : SUB_MULTIMEDIA_VIDEOOUTPUTERRORCODE_0100
* @tc.name : VideoOutputErrorCode ENAME
* @tc.desc : VideoOutputErrorCode ENAME
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_MULTIMEDIA_VIDEOOUTPUTERRORCODE_0100', 0, async function (done) {
console.info(TAG + "--------------SUB_MULTIMEDIA_VIDEOOUTPUTERRORCODE_0100------------")
console.info(TAG + "QualityLevel SUB_MULTIMEDIA_VIDEOOUTPUTERRORCODE_0100 : " + cameraObj.VideoOutputErrorCode.ERROR_UNKNOWN);
expect(cameraObj.VideoOutputErrorCode.ERROR_UNKNOWN).assertEqual(-1);
await sleep(1000);
done();
})
}
\ No newline at end of file
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/test/CameraJSUnitPhotoAsync.test.ets 已删除 100644 → 0
浏览文件 @ 119f5fb2
/*
* Copyright (C) 2022 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 cameraObj from '@ohos.multimedia.camera';
import image from '@ohos.multimedia.image';
import fileio from '@ohos.fileio';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
import bundle from '@ohos.bundle'
import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index';
const TAG = "CameraModuleTest: ";
// Define global variables
var camera0Input;
var camera1Input;
var cameraManager;
var previewOutputAsync;
var photoOutputAsync;
var captureSession;
var surfaceId1;
var camerasArray;
var Point1 = { x: 1, y: 1 }
var Point2 = { x: 2, y: 2 }
var Point3 = { x: 3, y: 3 }
var photosettings1 = {
rotation: 0,
quality: 0,
location: {
latitude: 12.9705,
longitude: 77.7329,
altitude: 920.0000,
},
}
var photosettings2 = {
rotation: 90,
quality: 1,
location: {
latitude: 20,
longitude: 78,
altitude: 8586,
},
}
var photosettings3 = {
quality: 2,
location: {
latitude: 0,
longitude: 0,
altitude: 0,
},
}
var photosettings4 = {
rotation: 180,
location: {
latitude: -1,
longitude: -1,
altitude: -1,
},
}
export default function cameraJSUnitPhotoAsync(surfaceId: any) {
async function getImageReceiverSurfaceId() {
console.log(TAG + 'Entering create Image receiver')
var receiver = image.createImageReceiver(640, 480, 4, 8)
console.log(TAG + 'before receiver check')
if (receiver !== undefined) {
console.log(TAG + 'Receiver is ok')
surfaceId1 = await receiver.getReceivingSurfaceId()
console.log(TAG + 'Received id: ' + JSON.stringify(surfaceId1))
} else {
console.log(TAG + 'Receiver is not ok')
}
}
function sleep(ms) {
console.info(TAG + "Entering sleep -> Promise constructor");
return new Promise(resolve => setTimeout(resolve, ms));
}
async function applyPermission() {
let appInfo = await bundle.getApplicationInfo('com.open.harmony.multimedia.cameratest', 0, 100);
let atManager = abilityAccessCtrl.createAtManager();
if (atManager != null) {
let tokenID = appInfo.accessTokenId;
console.info('[permission] case accessTokenID is ' + tokenID);
let permissionName1 = 'ohos.permission.CAMERA';
let permissionName2 = 'ohos.permission.MICROPHONE';
let permissionName3 = 'ohos.permission.MEDIA_LOCATION';
let permissionName4 = 'ohos.permission.READ_MEDIA';
let permissionName5 = 'ohos.permission.WRITE_MEDIA';
await atManager.grantUserGrantedPermission(tokenID, permissionName1, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName2, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName3, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName4, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName5, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
} else {
console.info('[permission] case apply permission failed, createAtManager failed');
}
}
describe('CameraJsUnitPhotoAsync', function () {
console.info(TAG + '----------CameraJsUnitPhotoAsync--------------')
beforeAll(async function () {
await applyPermission();
console.info('beforeAll case');
})
beforeEach(function () {
sleep(5000);
console.info('beforeEach case');
})
afterEach(async function () {
console.info('afterEach case');
})
afterAll(function () {
console.info('afterAll case');
})
console.info(TAG + "----------Camera-Precision Control-Async-------------");
/**
* @tc.number : GET_CAMERA_MANAGER
* @tc.name : Create camera manager instance async api
* @tc.desc : Create camera manager instance async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERA_MANAGER', 0, async function (done) {
console.info("--------------GET_CAMERA_MANAGER--------------");
cameraObj.getCameraManager(null, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Camera Manager success");
if (data != null || data != undefined) {
console.info(TAG + "Entering Camera Manager data is not null || undefined");
cameraManager = data;
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERA_MANAGER PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERA_MANAGER FAILED: " + err.message);
}
console.info(TAG + "Entering GET_CAMERA_MANAGER ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_STATUS_CALLBACK
* @tc.name : camera status callback on CameraManager async api
* @tc.desc : camera status callback on CameraManager async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_STATUS_CALLBACK', 0, async function (done) {
if (cameraManager == null || cameraManager == undefined) {
console.info(TAG + "Entering CAMERA_STATUS_CALLBACK cameraManager == null || undefined")
} else {
console.info(TAG + "Entering CAMERA_STATUS_CALLBACK to operate")
cameraManager.on('cameraStatus', async (err, data) => {
if (!err) {
console.info(TAG + "Camera status Callback on cameraManager is success");
if (data != null || data != undefined) {
console.info(TAG + "Camera status Callback CameraStatusInfo_Camera: " + data.camera);
console.info(TAG + "Camera status Callback CameraStatusInfo_Status: " + data.status);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_STATUS_CALLBACK FAILED: " + err.message);
}
await sleep(1000);
done();
})
}
await sleep(1000);
done();
})
/**
* @tc.number : GET_CAMERAS
* @tc.name : Get camera from cameramanager to get array of camera async api
* @tc.desc : Get camera from cameramanager to get array of camera async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERAS', 0, async function (done) {
console.info("--------------GET_CAMERAS--------------");
cameraManager.getCameras(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GetCameras success");
if (data != null || data != undefined) {
console.info(TAG + "Entering GetCameras data is not null || undefined");
camerasArray = data;
if (camerasArray != null && camerasArray.length > 0) {
for (var i = 0; i < camerasArray.length; i++) {
// Get the variables from camera object
var cameraId = camerasArray[i].cameraId;
console.info(TAG + "Entering GetCameras camera" + i + "Id: " + cameraId);
var cameraPosition = camerasArray[i].cameraPosition;
console.info(TAG + "Entering GetCameras camera" + i + "Position: " + cameraPosition);
var cameraType = camerasArray[i].cameraType;
console.info(TAG + "Entering GetCameras camera" + i + "Type: " + cameraType);
var connectionType = camerasArray[i].connectionType
console.info(TAG + "Entering GetCameras connection" + i + "Type: " + connectionType);
}
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERAS PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERAS FAILED cameraArray is null || undefined");
}
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERAS FAILED: " + err.message);
}
console.info(TAG + "Entering GET_CAMERAS ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/*CAMERA-0 Scripts*/
/**
* @tc.number : CREATE_CAMERA_INPUT
* @tc.name : Create camerainput from camera-0 cameraId async api
* @tc.desc : Create camerainput from camera-0 cameraId async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT', 0, async function (done) {
cameraManager.createCameraInput(camerasArray[0].cameraId, async (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + "Entering CREATE_CAMERA_INPUT data is not null || undefined");
camera0Input = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAMERA_INPUT PASSED with CameraID :" + camerasArray[0].cameraId);
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAMERA_INPUT FAILED: " + err.message);
}
console.info(TAG + "Entering CREATE_CAMERA_INPUT ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : CREATE_CAMERA_INPUT
* @tc.name : Create camerainput from camera-1 cameraId async api
* @tc.desc : Create camerainput from camera-1 cameraId async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT', 0, async function (done) {
cameraManager.createCameraInput(camerasArray[1].cameraId, async (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + "Entering CREATE_CAMERA_INPUT data is not null || undefined");
camera1Input = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAMERA_INPUT PASSED with CameraID :" + camerasArray[1].cameraId);
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAMERA_INPUT FAILED: " + err.message);
}
console.info(TAG + "Entering CREATE_CAMERA_INPUT ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_INPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_INPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering CameraInputCallbackOnError cameraInput == null || undefined");
} else {
console.info(TAG + "Entering CAMERA_INPUT_CALLBACK_ON_ERROR to operate");
camera0Input.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "cameraInput error callback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Error in CAMERA_INPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
}
await sleep(1000);
done();
})
/*PreviewOutput APIs test script*/
/**
* @tc.number : CREATE_PREVIEW_OUTPUT_SUCCESS
* @tc.name : Create PreviewOutput instance api
* @tc.desc : Create PreviewOutput instance api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PREVIEW_OUTPUT_SUCCESS', 0, async function (done) {
console.info(TAG + " Entering CREATE_PREVIEW_OUTPUT_SUCCESS to operate");
cameraObj.createPreviewOutput(surfaceId, async (err, data) => {
if (!err) {
console.info(TAG + " Entering createPreviewOutput success");
if (data != null || data != undefined) {
console.info(TAG + " Entering createPreviewOutput data is not null || undefined");
previewOutputAsync = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_PREVIEW_OUTPUT_SUCCESS PASSED" + previewOutputAsync);
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PREVIEW_OUTPUT_SUCCESS FAILED : " + err.message);
}
console.info(TAG + "Entering CREATE_PREVIEW_OUTPUT_SUCCESS ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Preview output callback on error api
* @tc.desc : Preview output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (previewOutputAsync == null || previewOutputAsync == undefined) {
console.info(TAG + "Entering PreviewOutputError callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_ERROR to operate");
previewOutputAsync.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PreviewOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*PhotoOutput APIs test script*/
/**
* @tc.number : CREATE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Create PhotoOutput instance api
* @tc.desc : Create PhotoOutput instance api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS to operate");
console.info(TAG + 'Entering getImageReceiverSurfaceId')
await getImageReceiverSurfaceId()
await sleep(1000)
cameraObj.createPhotoOutput(surfaceId1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering createPhotoOutput success");
if (data != null || data != undefined) {
console.info(TAG + "Entering createPhotoOutput data is not null || undefined");
photoOutputAsync = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering createPhotoOutput ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR to operate");
photoOutputAsync.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PhotoOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Error during PhotoOutput with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*CaptureSession APIs test script*/
/**
* @tc.number : CREATE_CAPTURE_SESSION_SUCCESS
* @tc.name : Create CaptureSession instance api
* @tc.desc : Create CaptureSession instance api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAPTURE_SESSION_SUCCESS', 0, async function (done) {
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_SUCCESS to operate");
cameraObj.createCaptureSession(null, async (err, data) => {
if (!err) {
console.info(TAG + "Entering createCaptureSession success");
if (data != null || data != undefined) {
console.info(TAG + "Entering createCaptureSession data is not null || undefined");
captureSession = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
//Capturesession callback
/**
* @tc.number : CAP_SES_CALLBACK_ON_ERROR
* @tc.name : CaptureSession callback on error api
* @tc.desc : CaptureSession callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAP_SES_CALLBACK_ON_ERROR', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering captureSession error callback captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAP_SES_CALLBACK_ON_ERROR to operate");
captureSession.on('error', async (err, data) => {
if (!err) {
console.info(TAG + " captureSession error callback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Error in CAP_SES_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*CaptureSession APIs*/
/**
* @tc.number : BEGIN_CONFIG_SUCCESS
* @tc.name : CaptureSession_Begin config api
* @tc.desc : CaptureSession_Begin config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('BEGIN_CONFIG_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering BeginConfig captureSession == null || undefined");
} else {
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS to operate");
captureSession.beginConfig(async (err, data) => {
if (!err) {
console.info(TAG + "Entering beginConfig success");
if (data != null || data != undefined) {
console.info(TAG + "Entering BeginConfig data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS beginConfig PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : ADD_INPUT_SUCCESS
* @tc.name : Add Input with camera1Input api
* @tc.desc : Add Input with camera1Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering Addinput captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_SUCCESS to operate");
captureSession.addInput(camera1Input, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddInput success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddInput data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_SUCCESS addInput PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering ADD_INPUT_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_SUCCESS
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Preview captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS to operate");
captureSession.addOutput(previewOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Preview : Success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Preview data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS ends here");
}
await sleep(1000);
done();
})
}
})
/**
* @tc.number : REMOVE_PREVIEW_OUTPUT_SUCCESS
* @tc.name : Remove preview Output api
* @tc.desc : Remove preview Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PREVIEW_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS to operate");
captureSession.removeOutput(previewOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove preview Output success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering Remove preview Output FAILED" + err.message);
console.info(TAG + "Entering Remove Preview Output ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_SUCCESS
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Preview captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS to operate");
captureSession.addOutput(previewOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Preview : Success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Preview data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS ends here");
}
await sleep(1000);
done();
})
}
})
/**
* @tc.number : COMMIT_CONFIG_SUCCESS
* @tc.name : commit config api
* @tc.desc : commit config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CommitConfig captureSession == null || undefined");
} else {
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS to operate");
captureSession.commitConfig(async (err, data) => {
if (!err) {
console.info(TAG + "Entering commitConfig success");
if (data != null || data != undefined) {
console.info(TAG + "Entering CommitConfig data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : isMirrorSupported_PHOTO_OUTPUT
* @tc.name : isMirrorSupported
* @tc.desc : isMirrorSupported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('isMirrorSupported_PHOTO_OUTPUT', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT to operate");
photoOutputAsync.isMirrorSupported(async (err, data) => {
if (!err) {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT is success");
console.info(TAG + "isMirrorSupported : " + data);
expect(true).assertTrue();
} else {
expect().assertFail();
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : setMirror_true
* @tc.name : setMirror true
* @tc.desc : setMirror true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_true', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_true to operate");
photoOutputAsync.setMirror(true, async (err, data) => {
if (!err) {
console.info(TAG + "Entering setMirror_true is success:");
console.info(TAG + "setMirror is : " + 'True');
expect(true).assertTrue();
} else {
expect().assertFail();
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : setMirror_false
* @tc.name : setMirror false
* @tc.desc : setMirror false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_false', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_false to operate");
photoOutputAsync.setMirror(false, async (err, data) => {
if (!err) {
console.info(TAG + "Entering setMirror_false is success");
console.info(TAG + "setMirror is : " + 'false');
expect(true).assertTrue();
} else {
expect().assertFail();
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*CaptureSession APIs*/
/**
* @tc.number : BEGIN_CONFIG_SUCCESS
* @tc.name : CaptureSession_Begin config api
* @tc.desc : CaptureSession_Begin config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('BEGIN_CONFIG_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering BeginConfig captureSession == null || undefined");
} else {
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS to operate");
captureSession.beginConfig(async (err, data) => {
if (!err) {
console.info(TAG + "Entering beginConfig success");
if (data != null || data != undefined) {
console.info(TAG + "Entering BeginConfig data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS beginConfig PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : REMOVE_INPUT_SUCCESS
* @tc.name : remove input api
* @tc.desc : remove input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_INPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
captureSession.removeInput(camera1Input, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove input success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering Remove Input FAILED" + err.message);
console.info(TAG + "Entering Remove Input ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
}
done();
})
/**
* @tc.number : ADD_INPUT_SUCCESS
* @tc.name : Add Input with camera0Input api
* @tc.desc : Add Input with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering Addinput captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_SUCCESS to operate");
captureSession.addInput(camera0Input, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddInput success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddInput data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_SUCCESS addInput PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering ADD_INPUT_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Photo captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
captureSession.addOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Photo success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Photo data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED: " + err.message);
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : REMOVE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Remove photo Output api
* @tc.desc : Remove photo Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS to operate");
captureSession.removeOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove photo Output success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering Remove photo Output FAILED" + err.message);
console.info(TAG + "Entering Remove photo Output ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
}
done();
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Photo captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
captureSession.addOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Photo success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Photo data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED: " + err.message);
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : COMMIT_CONFIG_SUCCESS
* @tc.name : commit config api
* @tc.desc : commit config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CommitConfig captureSession == null || undefined");
} else {
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS to operate");
captureSession.commitConfig(async (err, data) => {
if (!err) {
console.info(TAG + "Entering commitConfig success");
if (data != null || data != undefined) {
console.info(TAG + "Entering CommitConfig data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : FocusStateChange callback api
* @tc.desc : FocusStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering FocusStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0Input.on('focusStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "FocusState callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current FocusState is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : ExposureStateChange callback api
* @tc.desc : ExposureStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering ExposureStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0Input.on('exposureStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "ExposureStateChange callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current ExposureStateChange is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
//preview callback
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : Preview output callback on frame start api
* @tc.desc : Preview output callback on frame start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (previewOutputAsync == null || previewOutputAsync == undefined) {
console.info(TAG + "Entering PreviewStart frameStart Callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START to operate");
previewOutputAsync.on("frameStart", async (err, data) => {
if (!err) {
console.info(TAG + "PreviewStart frameStart Callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START FAILED : + err.message");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : Preview capture callback on frame end api
* @tc.desc : Preview capture callback on frame end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (previewOutputAsync == null || previewOutputAsync == undefined) {
console.info(TAG + "Entering PreviewOutput frameEnd Callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END to operate");
previewOutputAsync.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END Callback is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END FAILED : + err.message");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
//Capture callback
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_START
* @tc.name : Photo capture callback on capture start api
* @tc.desc : Photo capture callback on capture start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_START', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering Photo Capture Callback on CaptureStart photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_START to operate");
photoOutputAsync.on('captureStart', async (err, data) => {
if (!err) {
console.info(TAG + "Photo Capture Callback on CaptureStart is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START with captureId: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_END
* @tc.name : Photo capture callback on capture end api
* @tc.desc : Photo capture callback on capture end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_END', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END to operate");
photoOutputAsync.on('captureEnd', async (err, data) => {
if (!err) {
console.info(TAG + "captureEnd callback is success");
if (data != null || data != undefined) {
console.info(TAG + "captureEnd callback with captureId: " + data.captureId);
console.info(TAG + "captureEnd callback with frameCount: " + data.frameCount);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + 'PHOTO_CAP_CALLBACK_ON_CAPTURE_END FAILED' + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER
* @tc.name : Photo capture callback on frame shutter api
* @tc.desc : Photo capture callback on frame shutter api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER to operate");
photoOutputAsync.on('frameShutter', async (err, data) => {
if (!err) {
console.info(TAG + "frameShutter callback is success");
if (data != null || data != undefined) {
console.info(TAG + "frameShutter callback with captureId: " + data.captureId);
console.info(TAG + "frameShutter callback with timestamp: " + data.timestamp);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : CAPTURE_SESSION_START
* @tc.name : capture session start api
* @tc.desc : capture session start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_START', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CaptureSession Start captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_START to operate");
captureSession.start(async (err, data) => {
if (!err) {
console.info(TAG + "Entering captureSession.start success");
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_START PASSED");
}
else {
console.info(TAG + 'Entering CAPTURE_SESSION_START FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + "Entering CAPTURE_SESSION_START ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
//Location
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS to operate");
photoOutputAsync.capture(photosettings1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings1");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2
* @tc.name : Photo output capture with photosettings2 api
* @tc.desc : Photo output capture with photosettings2 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 to operate");
photoOutputAsync.capture(photosettings2, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings2 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings2 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 to operate");
photoOutputAsync.capture(photosettings3, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings3 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings3 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 ends here");
}
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS with Rotation-270
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 to operate");
photoOutputAsync.capture(photosettings4, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings4 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings4 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 ends here");
}
})
await sleep(1000);
done();
}
})
//FLASH Function API scripts
/**
* @tc.number : HAS_FLASH
* @tc.name : check if has flash-camera0Input api
* @tc.desc : check if has flash-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('HAS_FLASH', 0, async function (done) {
console.info(TAG + "hasFlash called.")
camera0Input.hasFlash(async (err, data) => {
if (!err) {
console.info(TAG + "Entering HAS_FLASH success");
if (data != null || data != undefined) {
console.info(TAG + "Entering HAS_FLASH data is not null || undefined");
console.info(TAG + "Entering HAS_FLASH PASSED with HAS_FLASH is: " + data);
expect(data).assertEqual(true);
}
} else {
console.info(TAG + "Entering HAS_FLASH FAILED : " + err.message);
expect().assertFail();
}
console.info(TAG + "Entering HAS_FLASH ends here");
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_OPEN_SUPPORTED
* @tc.name : check if flash mode open is supported-camera0Input api
* @tc.desc : check if flash mode open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_OPEN
* @tc.name : set flash mode open camera0 api
* @tc.desc : set flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_OPEN).assertEqual(1);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_OPEN ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_OPEN
* @tc.name : get flash mode open camera0 api
* @tc.desc : get flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN success");
if (data == 1) {
console.info(TAG + "GET_FLASH_MODE_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_OPEN PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_OPEN FAILED : " + err.message);
console.info(TAG + "GET_FLASH_MODE_OPEN ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_ALWAYS_OPEN SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_ALWAYS_OPEN supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : set flash mode always open camera0 api
* @tc.desc : set flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN).assertEqual(3);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : get flash mode always open camera0 api
* @tc.desc : get flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN success");
if (data == 3) {
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN FAILED : " + err.message);
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_AUTO_SUPPORTED
* @tc.name : check if flash mode auto is supported-camera0Input api
* @tc.desc : check if flash mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_AUTO SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_AUTO supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED FAILED :" + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_AUTO
* @tc.name : set flash mode auto camera0 api
* @tc.desc : set flash mode auto open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering SET_FLASH_MODE_AUTO PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_AUTO).assertEqual(2);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_AUTO
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO success");
if (data == 2) {
console.info(TAG + "GET_FLASH_MODE_AUTO data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_AUTO PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_AUTO FAILED :" + err.message);
console.info(TAG + "GET_FLASH_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_CLOSE_SUPPORTED
* @tc.name : check if flash mode close is supported-camera0Input api
* @tc.desc : check if flash mode close is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_CLOSE_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_CLOSE, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_CLOSE SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_CLOSE supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED FAILED :" + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_CLOSE
* @tc.name : set flash mode close camera0 api
* @tc.desc : set flash mode close open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_CLOSE, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_CLOSE).assertEqual(0);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_CLOSE
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE success");
if (data == 0) {
console.info(TAG + "GET_FLASH_MODE_CLOSE data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_CLOSE PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_CLOSE FAILED :" + err.message);
console.info(TAG + "GET_FLASH_MODE_CLOSE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_ZOOM_RATIO
* @tc.name : get zoom ratio camera-0 cameraId api
* @tc.desc : get zoom ratio camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_ZOOM_RATIO', 0, async function (done) {
console.info("--------------GET_ZOOM_RATIO--------------");
camera0Input.getZoomRatioRange(async (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + "Entering GET_ZOOM_RATIO data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering GET_ZOOM_RATIO Success " + data)
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_ZOOM_RATIO FAILED: " + err.message);
}
console.info(TAG + "Entering GET_ZOOM_RATIO ends here");
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_1_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_1_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(1, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 1");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(1);
console.info(TAG + "SET_GET_ZOOM_1_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_1_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_1_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_2_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_2_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(2, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 2");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(2);
console.info(TAG + "SET_GET_ZOOM_2_ASYNC PASSED ");
}
else {
expect().assertFail();
console.info(TAG + "GET_ZOOM_2_ASYNC FAILED" + err.message);
}
})
} else {
expect().assertFail();
console.info(TAG + "SET_ZOOM_2_ASYNC FAILED" + err.message);
}
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_3_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_3_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(3, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 3");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(3);
console.info(TAG + "SET_GET_ZOOM_3_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_3_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_3_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_4_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_4_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(4, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 4");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(4);
console.info(TAG + "SET_GET_ZOOM_4_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_4_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_4_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_5_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_5_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(5, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 5");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(5);
console.info(TAG + "SET_GET_ZOOM_5_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_5_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_5_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_6_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_6_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(6, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 6");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(6);
console.info(TAG + "SET_GET_ZOOM_6_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_6_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_6_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_LOCKED_SUPPORTED
* @tc.name : check if focus mode locked is supported-camera0Input api
* @tc.desc : check if focus mode locked is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Focus Mode Locked Supported SUCCESS: " + data);
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Focus Mode Locked Supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_LOCKED_SUPPORTED is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_LOCKED_SUPPORTED FAILED :" + err.message);
expect().assertFail()
console.info(TAG + "IS_FOCUS_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_LOCKED
* @tc.name : set focus mode locked camera0 api
* @tc.desc : set focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Mode Locked SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED FAILED : ")
expect().assertFail();
} else {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_LOCKED
* @tc.name : get focus mode locked camera0 api
* @tc.desc : get focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_LOCKED to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Mode Locked SUCCESS: " + data);
console.info(TAG + "Get Focus Mode Locked data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_FOCUS_MODE_LOCKED PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_LOCKED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCAL_LENGTH
* @tc.name : get focal length camera0 api
* @tc.desc : get focal length camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCAL_LENGTH', 0, async function (done) {
console.info(TAG + "Entering GET_FOCAL_LENGTH to operate");
camera0Input.getFocalLength(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focal length SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focal length is: " + JSON.stringify(data));
expect(data).assertEqual(3.4600000381469727);
console.info(TAG + "GET_FOCAL_LENGTH PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCAL_LENGTH FAILED : " + err.message);
console.info(TAG + "GET_FOCAL_LENGTH ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode manual
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT_focus mode manual', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode manual
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT_focus mode manual', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_MANUAL_SUPPORTED
* @tc.name : check if focus mode manual is supported-camera0Input api
* @tc.desc : check if focus mode manual is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_MANUAL_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_MANUAL, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_MANUAL_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED FAILED " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_MANUAL
* @tc.name : set focus mode manual camera0 api
* @tc.desc : set focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_MANUAL);
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_MANUAL).assertEqual(0)
}
else {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_MANUAL
* @tc.name : get focus mode manual camera0 api
* @tc.desc : get focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_MANUAL data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_FOCUS_MODE_MANUAL PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_MANUAL FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_MANUAL ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PhotoOutputCapture photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode continuous
* @tc.name : set focus Point locked camera0 api
* @tc.desc : set focus Point locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point2, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode continuous
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_CONTINUOUS_SUPPORTED
* @tc.name : check if focus mode continuous is supported-camera0Input api
* @tc.desc : check if focus mode continuous is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_CONTINUOUS_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_CONTINOUS_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_CONTINUOUS
* @tc.name : set focus mode continuous camera0 api
* @tc.desc : set focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
expect(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO).assertEqual(1);
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS PASSED");
}
else {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_CONTINUOUS
* @tc.name : get focus mode continuous camera0 api
* @tc.desc : get focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PhotoOutputCapture photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode auto
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point3, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode auto
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_AUTO_SUPPORTED
* @tc.name : check if focus mode auto is supported-camera0Input api
* @tc.desc : check if focus mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_AUTO_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_AUTO
* @tc.name : set focus mode auto camera0 api
* @tc.desc : set focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_AUTO);
if (data != null || data != undefined) {
expect(cameraObj.FocusMode.FOCUS_MODE_AUTO).assertEqual(2);
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO PASSED")
}
} else {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_AUTO
* @tc.name : get focus mode auto camera0 api
* @tc.desc : get focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_AUTO data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(2);
console.info(TAG + "GET_FOCUS_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_AUTO FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PhotoOutputCapture photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : IS_EXPOSURE_MODE_LOCKED_SUPPORTED
* @tc.name : check if exposure mode locked is supported-camera0Input api
* @tc.desc : check if exposure mode locked is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode Locked supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode Locked supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_Locked_Supported is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_LOCKED
* @tc.name : set exposure mode locked camera0 api
* @tc.desc : set exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode Locked, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED);
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED FAILED")
expect().AssertFail();
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_LOCKED
* @tc.name : get exposure mode locked camera0 api
* @tc.desc : get exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_LOCKED to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED
* @tc.name : check if exposure mode continuous auto is supported-camera0Input api
* @tc.desc : check if exposure mode continuous auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode continuous Auto supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode continuous Auto supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_continuous_Auto_Supported is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : set exposure mode continuous auto camera0 api
* @tc.desc : set exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode continuous auto,current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED")
expect().AssertFail();
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : get exposure mode continuous auto camera0 api
* @tc.desc : get exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASRANGE
* @tc.name : get exposure bias range camera0 api
* @tc.desc : get exposure bias range camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASRANGE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASRANGE to operate");
camera0Input.getExposureBiasRange(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias range SUCCESS");
console.info(TAG + "Current Exposure bias range is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_BIASRANGE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASRANGE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASRANGE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure -4
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(-4, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "-4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode locked
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode auto
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode auto
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_AUTO_SUPPORTED
* @tc.name : check if exposure mode auto is supported-camera0Input api
* @tc.desc : check if exposure mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode Auto supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode Auto supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_Auto_Supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_AUTO
* @tc.name : set exposure mode auto camera0 api
* @tc.desc : set exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode auto,current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
if (data != null || data != undefined) {
expect(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO).assertEqual(1);
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO PASSED")
}
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_AUTO
* @tc.name : get exposure mode auto camera0 api
* @tc.desc : get exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('GET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_AUTO to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure Mode SUCCESS");
console.info(TAG + "Get Exposure Mode data is not null || undefined: ");
console.info(TAG + "Current ExposureMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
*/
/**
* @tc.number : PHOTOOUTPUT_CAPTURE
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PhotoOutputCapture photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "1");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode auto
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT_exposure
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point2, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS to operate");
photoOutputAsync.capture(photosettings1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings1");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(4, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode continuous auto
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point3, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 to operate");
photoOutputAsync.capture(photosettings2, async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture with photosettings2");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure -5
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(-5, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "-4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode locked
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure 6
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(6, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
})
/*CaptureSession APIs test script*/
/**
* @tc.number : CAPTURE_SESSION_STOP
* @tc.name : capture session stop api
* @tc.desc : capture session stop api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_STOP', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CAPTURE_SESSION_STOP captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_STOP to operate");
captureSession.stop(async (err, data) => {
if (!err) {
console.info(TAG + "Entering CAPTURE_SESSION_STOP captureSession.stop success");
if (data != null || data != undefined) {
console.info(TAG + "Entering captureSession.stop data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_STOP captureSession.stop PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CAPTURE_SESSION_STOP FAILED : " + err.message);
console.info(TAG + "Entering CAPTURE_SESSION_STOP ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : CAPTURE_SESSION_RELEASE
* @tc.name : capture session release api
* @tc.desc : capture session release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_RELEASE', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE to operate");
captureSession.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering captureSession.release success");
if (data != null || data != undefined) {
console.info(TAG + "Entering captureSession.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE FAILED: " + err.message);
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE ends here");
await sleep(1000);
done();
}
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUPUT_RELEASE
* @tc.name : photoOutput release api
* @tc.desc : photoOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUPUT_RELEASE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUPUT_RELEASE photoOutputAsync == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUPUT_RELEASE to operate");
photoOutputAsync.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutputAsync.release success");
expect(true).assertTrue();
console.info(TAG + "Entering PHOTOOUPUT_RELEASE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUPUT_RELEASE FAILED: " + err.message);
console.info(TAG + "Entering photoOutputAsync.release ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PREVIEWOUPUT_RELEASE
* @tc.name : previewOutput release api
* @tc.desc : previewOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEWOUPUT_RELEASE', 0, async function (done) {
if (previewOutputAsync == null || previewOutputAsync == undefined) {
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE previewOutputAsync == null || undefined");
} else {
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE to operate");
previewOutputAsync.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering previewOutputAsync.release success");
console.info(TAG + "Entering previewOutputAsync.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE FAILED: " + err.message);
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE ends here");
await sleep(1000);
done();
}
})
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : CAMERAINPUT_RELEASE_SUCCESS
* @tc.name : camera Input release api
* @tc.desc : camera Input release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERAINPUT_RELEASE_SUCCESS', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS camera0Input == null || undefined");
} else {
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS to operate");
camera0Input.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering camera0Input.release success");
if (data != null || data != undefined) {
console.info(TAG + "Entering camera0Input.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS ends here");
await sleep(1000);
done();
}
})
await sleep(1000);
done();
}
})
})
}
\ No newline at end of file
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/test/CameraJSUnitPhotoPromise.test.ets 已删除 100644 → 0
浏览文件 @ 119f5fb2
/*
* Copyright (C) 2022 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 cameraObj from '@ohos.multimedia.camera';
import image from '@ohos.multimedia.image';
import fileio from '@ohos.fileio';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
import bundle from '@ohos.bundle'
import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index';
const TAG = "CameraModuleTest: ";
// Define global variables
var camera0InputPromise;
var cameraManagerPromise;
var previewOutputPromise;
var photoOutputPromise;
var CaptureSessionPromise;
var surfaceId1;
var camerasArrayPromise
var camera1InputPromise;
var Point1 = { x: 1, y: 1 }
var Point2 = { x: 2, y: 2 }
var Point3 = { x: 3, y: 3 }
var photosettings1 = {
rotation: 0,
quality: 0,
location: {
latitude: 12.9705,
longitude: 77.7329,
altitude: 920.0000,
},
}
var photosettings2 = {
rotation: 90,
quality: 1,
location: {
latitude: 20,
longitude: 78,
altitude: 8586,
},
}
var photosettings3 = {
quality: 2,
location: {
latitude: 0,
longitude: 0,
altitude: 0,
},
}
var photosettings4 = {
rotation: 180,
location: {
latitude: -1,
longitude: -1,
altitude: -1,
},
}
export default function cameraJSUnitPhotoPromise(surfaceId: any) {
async function getImageReceiverSurfaceId() {
console.log(TAG + 'Entering create Image receiver')
var receiver = image.createImageReceiver(640, 480, 4, 8)
console.log(TAG + 'before receiver check')
if (receiver !== undefined) {
console.log(TAG + 'Receiver is ok')
surfaceId1 = await receiver.getReceivingSurfaceId()
console.log(TAG + 'Received id: ' + JSON.stringify(surfaceId1))
} else {
console.log(TAG + 'Receiver is not ok')
}
}
function sleep(ms) {
console.info(TAG + "Entering sleep -> Promise constructor");
return new Promise(resolve => setTimeout(resolve, ms));
}
async function applyPermission() {
let appInfo = await bundle.getApplicationInfo('com.open.harmony.multimedia.cameratest', 0, 100);
let atManager = abilityAccessCtrl.createAtManager();
if (atManager != null) {
let tokenID = appInfo.accessTokenId;
console.info('[permission] case accessTokenID is ' + tokenID);
let permissionName1 = 'ohos.permission.CAMERA';
let permissionName2 = 'ohos.permission.MICROPHONE';
let permissionName3 = 'ohos.permission.MEDIA_LOCATION';
let permissionName4 = 'ohos.permission.READ_MEDIA';
let permissionName5 = 'ohos.permission.WRITE_MEDIA';
await atManager.grantUserGrantedPermission(tokenID, permissionName1, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName2, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName3, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName4, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName5, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
} else {
console.info('[permission] case apply permission failed, createAtManager failed');
}
}
describe('CameraJsUnitPhotoPromise', function () {
console.info(TAG + '----------CameraJsUnitPhotoPromise--------------')
beforeAll(async function () {
await applyPermission();
console.info('beforeAll case');
})
beforeEach(function () {
sleep(5000);
console.info('beforeEach case');
})
afterEach(async function () {
console.info('afterEach case');
})
afterAll(function () {
console.info('afterAll case');
})
console.info(TAG + "----------Camera-PhotoMode-Promise-------------");
/**
* @tc.number : GET_CAMERA_MANAGER_PROMISE
* @tc.name : Create camera manager instance promise api
* @tc.desc : Create camera manager instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERA_MANAGER_PROMISE', 0, async function (done) {
console.info("--------------GET_CAMERA_MANAGER_PROMISE--------------");
cameraManagerPromise = await cameraObj.getCameraManager(null);
console.info(TAG + "Entering Get camera manager cameraManagerPromise: " + JSON.stringify(cameraManagerPromise));
if (cameraManagerPromise != null && cameraManagerPromise != undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERA_MANAGER_PROMISE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERA_MANAGER_PROMISE FAILED : ");
}
console.info(TAG + "Entering GET_CAMERA_MANAGER_PROMISE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_STATUS_CALLBACK
* @tc.name : camera status callback on CameraManager async api
* @tc.desc : camera status callback on CameraManager async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_STATUS_CALLBACK', 0, async function (done) {
if (cameraManagerPromise == null || cameraManagerPromise == undefined) {
console.info(TAG + 'Entering camera status callback cameraManagerPromise == null || undefined')
} else {
console.info(TAG + 'Entering CAMERA_STATUS_CALLBACK to operate')
cameraManagerPromise.on('cameraStatus', async (err, data) => {
if (!err) {
console.info(TAG + "CAMERA_STATUS_CALLBACK cameraManagerPromise is success");
if (data != null || data != undefined) {
console.info(TAG + "Camera status Callback CameraStatusInfo_Camera: " + data.camera);
console.info(TAG + "Camera status Callback CameraStatusInfo_Status: " + data.status);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_STATUS_CALLBACK FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : GET_CAMERAS_PROMISE
* @tc.name : Get camera from cameramanager to get array of camera promise api
* @tc.desc : Get camera from cameramanager to get array of camera promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERAS_PROMISE', 0, async function (done) {
console.info("--------------GET_CAMERAS_PROMISE--------------");
camerasArrayPromise = await cameraManagerPromise.getCameras();
console.info(TAG + "Entering Get Cameras: " + JSON.stringify(camerasArrayPromise));
if (camerasArrayPromise != null && camerasArrayPromise.length > 0) {
console.info(TAG + "Entering Get Cameras success");
for (var i = 0; i < camerasArrayPromise.length; i++) {
// Get the variables from camera object
var cameraId = camerasArrayPromise[i].cameraId;
console.info(TAG + "Entering Get Cameras camera" + i + "Id: " + cameraId);
var cameraPosition = camerasArrayPromise[i].cameraPosition;
console.info(TAG + "Entering Get Cameras camera" + i + "Position: " + cameraPosition);
var cameraType = camerasArrayPromise[i].cameraType;
console.info(TAG + "Entering Get Cameras camera" + i + "Type: " + cameraType);
var connectionType = camerasArrayPromise[i].connectionType
console.info(TAG + "Entering Get Cameras connection" + i + "Type: " + connectionType);
}
expect(true).assertTrue();
console.info(TAG + "Entering GET_CAMERAS_PROMISE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering GET_CAMERAS_PROMISE FAILED : ");
}
console.info(TAG + "Entering GET_CAMERAS_PROMISE ends here");
await sleep(1000);
done();
})
/*CAMERA-0 Scripts*/
/**
* @tc.number : CREATE_CAMERA_INPUT_PROMISE
* @tc.name : Create camerainput from camera-0 cameraId promise api
* @tc.desc : Create camerainput from camera-0 cameraId promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT_PROMISE', 0, async function (done) {
console.info("--------------CAMERA-0 STARTS HERE--------------");
console.info("--------------CREATE_CAMERA_INPUT_PROMISE--------------");
camera0InputPromise = await cameraManagerPromise.createCameraInput(camerasArrayPromise[0].cameraId);
console.info(TAG + "Entering Create camerainput camera0InputPromise: " + JSON.stringify(camera0InputPromise));
if (camera0InputPromise != null && camera0InputPromise != undefined) {
console.info(TAG + "Entering Create camerainput camera0InputPromise is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE FAILED : ");
}
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : CREATE_CAMERA_INPUT_PROMISE_Camera1
* @tc.name : Create camerainput from camera-1 cameraId promise api
* @tc.desc : Create camerainput from camera-1 cameraId promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT_PROMISE_Camera1', 0, async function (done) {
console.info("--------------CREATE_CAMERA_INPUT_PROMISE--------------");
camera1InputPromise = await cameraManagerPromise.createCameraInput(camerasArrayPromise[1].cameraId);
console.info(TAG + "Entering Create camerainput camera1InputPromise: " + JSON.stringify(camera1InputPromise));
if (camera1InputPromise != null && camera1InputPromise != undefined) {
console.info(TAG + "Entering Create camerainput camera1InputPromise is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE FAILED : ");
}
console.info(TAG + "Entering CREATE_CAMERA_INPUT_PROMISE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : CAMERA_INPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_INPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering CAMERA_INPUT_CALLBACK_ON_ERROR camera0InputPromise == null || undefined");
} else {
console.info(TAG + "Entering CAMERA_INPUT_CALLBACK_ON_ERROR to operate");
camera0InputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "camera0InputPromise error callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Error during camera0InputPromise with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*PreviewOutput APIs test script*/
/**
* @tc.number : CREATE_PREVIEW_OUTPUT_SUCCESS_PROMISE
* @tc.name : Create PreviewOutput instance promise api
* @tc.desc : Create PreviewOutput instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PREVIEW_OUTPUT_SUCCESS_PROMISE', 0, async function (done) {
console.info(TAG + " Entering CREATE_PREVIEW_OUTPUT_SUCCESS_PROMISE to operate");
previewOutputPromise = await cameraObj.createPreviewOutput(surfaceId);
console.info(TAG + " Entering createPreviewOutput success");
if (previewOutputPromise != null || previewOutputPromise != undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering createPreviewOutput PASSED: " + JSON.stringify(previewOutputPromise));
}
else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PREVIEW_OUTPUT_SUCCESS_PROMISE FAILED : ");
console.info(TAG + "Entering CREATE_PREVIEW_OUTPUT_SUCCESS_PROMISE ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Preview output callback on error api
* @tc.desc : Preview output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering Preview output callback on error previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_ERROR to operate");
previewOutputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PreviewOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*PhotoOutput APIs test script*/
/**
* @tc.number : CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE
* @tc.name : Create PhotoOutput instance promise api
* @tc.desc : Create PhotoOutput instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE', 0, async function (done) {
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE to operate");
console.info(TAG + 'Entering getImageReceiverSurfaceId')
await getImageReceiverSurfaceId()
await sleep(1000)
photoOutputPromise = await cameraObj.createPhotoOutput(surfaceId1);
console.info(TAG + "Entering createPhotoOutput success");
if (photoOutputPromise != null || photoOutputPromise != undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE FAILED : ");
console.info(TAG + "Entering createPhotoOutput ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : PHOTO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo output callback on error photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR to operate");
photoOutputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PhotoOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*CaptureSession APIs test script*/
/**
* @tc.number : CREATE_CAPTURE_SESSION_PROMISE
* @tc.name : Create CaptureSession instance promise api
* @tc.desc : Create Capturesession instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAPTURE_SESSION_PROMISE', 0, async function (done) {
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_PROMISE to operate");
CaptureSessionPromise = await cameraObj.createCaptureSession(null);
console.info(TAG + "Entering createCaptureSession success");
if (CaptureSessionPromise != null || CaptureSessionPromise != undefined) {
console.info(TAG + "Entering createCaptureSession data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_PROMISE FAILED : ");
console.info(TAG + "Entering CREATE_CAPTURE_SESSION_PROMISE ends here");
}
await sleep(1000);
done();
})
//Capturesession callback
/**
* @tc.number : CAP_SES_CALLBACK_ON_ERROR
* @tc.name : CaptureSession callback on error api
* @tc.desc : CaptureSession callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAP_SES_CALLBACK_ON_ERROR', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering CaptureSession callback on error captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAP_SES_CALLBACK_ON_ERROR to operate");
CaptureSessionPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + " captureSession errorcallback is success");
if (data != null || data != undefined) {
console.info(TAG + "Error CAP_SES_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/*CaptureSession APIs*/
/**
* @tc.number : CREATE_BEGIN_CONFIG_PROMISE
* @tc.name : CaptureSession_Begin config promise api
* @tc.desc : CaptureSession_Begin config promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_BEGIN_CONFIG_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering CaptureSession_Begin config captureSession == null || undefined");
} else {
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_PROMISE to operate");
const promise = await CaptureSessionPromise.beginConfig();
console.info(TAG + "Entering beginConfig success:");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_PROMISE beginConfig PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_PROMISE FAILED : ");
}
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_PROMISE ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_INPUT_PROMISE
* @tc.name : Add Input with camera0Input api
* @tc.desc : Add Input with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Add Input captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_PROMISE to operate");
const Promise = await CaptureSessionPromise.addInput(camera1InputPromise);
console.info(TAG + "Entering Add Input addInput success");
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_PROMISE addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_PROMISE FAILED: ");
}
console.info(TAG + "Entering ADD_INPUT_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_PROMISE
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Add preview Output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE to operate");
const promise = await CaptureSessionPromise.addOutput(previewOutputPromise);
console.info(TAG + "Entering Add preview Output : Success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE FAILED : ");
}
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : REMOVE_PREVIEW_OUTPUT_SUCCESS
* @tc.name : Remove preview Output api
* @tc.desc : Remove preview Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PREVIEW_OUTPUT_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Remove preview Output captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
const Promise = await CaptureSessionPromise.removeOutput(previewOutputPromise);
console.info(TAG + "Entering Remove preview Output success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_PROMISE
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Add preview Output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE to operate");
const promise = await CaptureSessionPromise.addOutput(previewOutputPromise);
console.info(TAG + "Entering Add preview Output : Success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE FAILED : ");
}
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : COMMIT_CONFIG_SUCCESS
* @tc.name : commit config api
* @tc.desc : commit config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering commit config captureSession == null || undefined");
} else {
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS to operate");
const promise = await CaptureSessionPromise.commitConfig();
console.info(TAG + "Entering commit config commitConfig success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig FAILED : ");
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig ends here");
}
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : isMirrorSupported_PHOTO_OUTPUT
* @tc.name : isMirrorSupported
* @tc.desc : isMirrorSupported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('isMirrorSupported_PHOTO_OUTPUT', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT to operate");
await photoOutputPromise.isMirrorSupported()
.then(function (data) {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT is success");
console.info(TAG + "isMirrorSupported : " + data);
expect(true).assertTrue();
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "isMirrorSupported_PHOTO_OUTPUT FAILED : " + err.message);
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : setMirror_true
* @tc.name : setMirror true
* @tc.desc : setMirror true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_true', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_true to operate");
await photoOutputPromise.setMirror(true).then(function (data) {
console.info(TAG + "Entering setMirror_true is success:");
console.info(TAG + "setMirror is : " + 'True');
expect(true).assertTrue();
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "setMirror_true FAILED : " + err.message);
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : setMirror_false
* @tc.name : setMirror false
* @tc.desc : setMirror false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_false', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_false to operate");
await photoOutputPromise.setMirror(false)
.then(function (data) {
console.info(TAG + "Entering setMirror_false is success:");
console.info(TAG + "setMirror is : " + 'false');
expect(true).assertTrue();
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "setMirror_false FAILED : " + err.message);
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : CREATE_BEGIN_CONFIG_SUCCESS_PROMISE
* @tc.name : CaptureSession_Begin config promise api
* @tc.desc : CaptureSession_Begin config promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_BEGIN_CONFIG_SUCCESS_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_SUCCESS_PROMISE to operate");
const promise = await CaptureSessionPromise.beginConfig();
console.info(TAG + "Entering beginConfig success:");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_BEGIN_CONFIG_SUCCESS_PROMISE beginConfig PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering beginConfig FAILED");
}
console.info(TAG + "Entering beginConfig ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : REMOVE_INPUT_SUCCESS
* @tc.name : remove input api
* @tc.desc : remove input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_INPUT_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
const Promise = await CaptureSessionPromise.removeInput(camera1InputPromise);
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_INPUT_PROMISE
* @tc.name : Add Input with camera0Input api
* @tc.desc : Add Input with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Add Input captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_PROMISE to operate");
const Promise = await CaptureSessionPromise.addInput(camera0InputPromise);
console.info(TAG + "Entering Add Input addInput success");
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_PROMISE addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_PROMISE FAILED: ");
}
console.info(TAG + "Entering ADD_INPUT_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering Add output with photo output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
const promise = await CaptureSessionPromise.addOutput(photoOutputPromise);
console.info(TAG + "Entering Add output with photo output success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED ");
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : REMOVE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Remove photo Output api
* @tc.desc : Remove photo Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
const Promise = await CaptureSessionPromise.removeOutput(photoOutputPromise);
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS addInput success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
const promise = await CaptureSessionPromise.addOutput(photoOutputPromise);
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED ");
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : COMMIT_CONFIG_SUCCESS
* @tc.name : commit config api
* @tc.desc : commit config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering commit config captureSession == null || undefined");
} else {
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS to operate");
const promise = await CaptureSessionPromise.commitConfig();
console.info(TAG + "Entering commit config commitConfig success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig FAILED : ");
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig ends here");
}
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : FocusStateChange callback api
* @tc.desc : FocusStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering FocusStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0InputPromise.on('focusStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "FocusState callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current FocusState is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : ExposureStateChange callback api
* @tc.desc : ExposureStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering ExposureStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0InputPromise.on('exposureStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "ExposureStateChange callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current ExposureStateChange is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
// callback related API
//preview callback
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : Preview output callback on frame start api
* @tc.desc : Preview output callback on frame start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering Preview output callback on frame start previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START to operate");
previewOutputPromise.on('frameStart', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START FAILED :" + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : Preview capture callback on frame end api
* @tc.desc : Preview capture callback on frame end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering Preview capture callback on frame end previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END to operate");
previewOutputPromise.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END FAILED : + err.message");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
//Capture callback
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_START
* @tc.name : Photo capture callback on capture start api
* @tc.desc : Photo capture callback on capture start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_START', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on capture start photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_START to operate");
photoOutputPromise.on('captureStart', async (err, data) => {
if (!err) {
console.info(TAG + "CaptureStart Callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START with captureId: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_END
* @tc.name : Photo capture callback on capture end api
* @tc.desc : Photo capture callback on capture end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_END', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on capture end photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END to operate");
photoOutputPromise.on('captureEnd', async (err, data) => {
if (!err) {
console.info(TAG + "captureEnd callback is success");
if (data != null || data != undefined) {
console.info(TAG + "captureEnd callback with captureId: " + data.captureId);
console.info(TAG + "captureEnd callback with frameCount: " + data.frameCount);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + 'PHOTO_CAP_CALLBACK_ON_CAPTURE_END FAILED' + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER
* @tc.name : Photo capture callback on frame shutter api
* @tc.desc : Photo capture callback on frame shutter api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on frame shutter photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER to operate");
photoOutputPromise.on('frameShutter', async (err, data) => {
if (!err) {
console.info(TAG + "frameShutter callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER with captureId: " + data.captureId);
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER with timestamp: " + data.timestamp);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER FAILED: " + err.message);
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : CAPTURE_SESSION_START_SUCCESS
* @tc.name : capture session start api
* @tc.desc : capture session start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_START_SUCCESS', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering capture session start captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS to operate");
await CaptureSessionPromise.start();
console.info(TAG + "Entering captureSession start success");
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS PASSED");
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
//Location
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputPromise.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo output capture with photosettings photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS to operate");
await photoOutputPromise.capture(photosettings1)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with settings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings1 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 FAILED:" + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo output capture with photosettings photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 to operate");
await photoOutputPromise.capture(photosettings2)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with settings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings2 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 FAILED:" + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo output capture with photosettings photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 to operate");
await photoOutputPromise.capture(photosettings3)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with settings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings3 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 :" + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS3 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 to operate");
await photoOutputPromise.capture(photosettings4)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with settings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings4 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS4 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
//FLASH Function API scripts
/**
* @tc.number : HAS_FLASH
* @tc.name : check if has flash-camera0Input api
* @tc.desc : check if has flash-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('HAS_FLASH', 0, async function (done) {
console.info("--------------HAS_FLASH--------------");
console.info(TAG + 'hasFlash called.')
var hasFlashPromise = await camera0InputPromise.hasFlash();
console.info(TAG + "Entering HAS_FLASH success");
if (hasFlashPromise != null || hasFlashPromise != undefined) {
console.info(TAG + "Entering HAS_FLASH data is not null || undefined");
console.info(TAG + "Entering HAS_FLASH PASSED with HAS_FLASH is: " + JSON.stringify(hasFlashPromise));
expect(hasFlashPromise).assertEqual(true);
}
else {
console.info(TAG + "Entering HAS_FLASH FAILED : ");
expect().assertFail();
}
console.info(TAG + "Entering HAS_FLASH ends here");
await sleep(1000)
done();
})
/**
* @tc.number : IS_FLASH_MODE_OPEN_SUPPORTED
* @tc.name : check if flash mode open is supported-camera0Input api
* @tc.desc : check if flash mode open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED to operate");
var isFMOpenSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED SUCCESS ");
if (isFMOpenSupported != null || isFMOpenSupported != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + JSON.stringify(isFMOpenSupported));
expect(isFMOpenSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_OPEN
* @tc.name : set flash mode open camera0 api
* @tc.desc : set flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN to operate");
var SetFMOpen = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMOpen))
if (SetFMOpen == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_OPEN).assertEqual(1);
} else {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_OPEN ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_OPEN
* @tc.name : get flash mode open camera0 api
* @tc.desc : get flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN to operate");
var GetFMOpen = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_OPEN success: " + JSON.stringify(GetFMOpen));
if (GetFMOpen == 1) {
console.info(TAG + "GET_FLASH_MODE_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + JSON.stringify(GetFMOpen));
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_OPEN PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_OPEN FAILED : ");
console.info(TAG + "GET_FLASH_MODE_OPEN ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED to operate");
var isFMAlwaysOpenSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED SUCCESS ");
if (isFMAlwaysOpenSupported != null || isFMAlwaysOpenSupported != undefined) {
console.info(TAG + "Entering FLASH_MODE_ALWAYS_OPEN data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + isFMAlwaysOpenSupported);
expect(isFMAlwaysOpenSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : set flash mode always open camera0 api
* @tc.desc : set flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN to operate");
var SetFMAlwaysOpen = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMAlwaysOpen))
if (SetFMAlwaysOpen == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN).assertEqual(3)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : get flash mode always open camera0 api
* @tc.desc : get flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN to operate");
var GetFMAlwaysOpen = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN success");
if (GetFMAlwaysOpen == 3) {
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMAlwaysOpen);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN FAILED : ");
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_AUTO_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED to operate");
var isFMAutoSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED SUCCESS ");
if (isFMAutoSupported != null || isFMAutoSupported != undefined) {
console.info(TAG + "Entering FLASH_MODE_AUTO data is not null || undefined");
console.info(TAG + "FLASH_MODE_AUTO supported is: " + isFMAutoSupported);
expect(isFMAutoSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_AUTO
* @tc.name : set flash mode auto camera0 api
* @tc.desc : set flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO to operate");
var SetFMAlwaysAuto = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "SetFMAlwaysAuto: " + JSON.stringify(SetFMAlwaysAuto))
if (SetFMAlwaysAuto == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering SET_FLASH_MODE_AUTO PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_AUTO).assertEqual(2)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_AUTO
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO to operate");
var GetFMAuto = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_AUTO success");
if (GetFMAuto == 2) {
console.info(TAG + "GET_FLASH_MODE_AUTO data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMAuto);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_AUTO FAILED : ");
console.info(TAG + "GET_FLASH_MODE_AUTO ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : IS_FLASH_MODE_CLOSE_SUPPORTED
* @tc.name : check if flash mode close is supported-camera0Input api
* @tc.desc : check if flash mode close is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_CLOSE_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED to operate");
var isFMCloseSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED SUCCESS ");
if (isFMCloseSupported != null || isFMCloseSupported != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_CLOSE supported is: " + isFMCloseSupported);
expect(isFMCloseSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FLASH_MODE_CLOSE
* @tc.name : set flash mode close camera0 api
* @tc.desc : set flash mode close camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE to operate");
var SetFMClose = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMClose))
if (SetFMClose == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_CLOSE).assertEqual(0)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : GET_FLASH_MODE_CLOSE
* @tc.name : get flash mode close camera0 api
* @tc.desc : get flash mode close camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE to operate");
var GetFMClose = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE success");
if (GetFMClose == 0) {
console.info(TAG + "GET_FLASH_MODE_CLOSE data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMClose);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_CLOSE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_CLOSE FAILED : ");
console.info(TAG + "GET_FLASH_MODE_CLOSE ends here");
}
await sleep(1000);
done();
})
//ZOOM Function
/**
* @tc.number : GET_ZOOM_RATIO_PROMISE
* @tc.name : get zoom ratio camera-0 cameraId api promise api
* @tc.desc : get zoom ratio camera-0 cameraId api promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_ZOOM_RATIO_PROMISE', 0, async function (done) {
console.info("--------------GET_ZOOM_RATIO_PROMISE--------------");
var getZoomRatioPromise = await camera0InputPromise.getZoomRatioRange();
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE getZoomRatioPromise: " + JSON.stringify(getZoomRatioPromise));
if (getZoomRatioPromise != null && getZoomRatioPromise != undefined) {
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE setZoomRatioPromise is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE success: " + JSON.stringify(getZoomRatioPromise));
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE FAILED");
}
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_1_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_1_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(1);
console.info(TAG + "setZoomRatio success: 1");
console.info(TAG + "getZoomRatio called")
var getpromise1 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise1);
if (getpromise1 != null && getpromise1 != undefined) {
expect(getpromise1).assertEqual(1);
console.info(TAG + "SET_GET_ZOOM_1_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_1_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_2_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_2_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(2);
console.info(TAG + "setZoomRatio success: 2");
console.info(TAG + "getZoomRatio called")
var getpromise2 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise2);
if (getpromise2 != null && getpromise2 != undefined) {
expect(getpromise2).assertEqual(2);
console.info(TAG + "SET_GET_ZOOM_2_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_2_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_3_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_3_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(3);
console.info(TAG + "setZoomRatio success: 3");
console.info(TAG + "getZoomRatio called")
var getpromise3 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise3);
if (getpromise3 != null && getpromise3 != undefined) {
expect(getpromise3).assertEqual(3);
console.info(TAG + "SET_GET_ZOOM_3_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_3_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_4_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_4_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(4);
console.info(TAG + "setZoomRatio success: 4");
console.info(TAG + "getZoomRatio called")
var getpromise4 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise4);
if (getpromise4 != null && getpromise4 != undefined) {
expect(getpromise4).assertEqual(4);
console.info(TAG + "SET_GET_ZOOM_4_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_4_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_5_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_5_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(5);
console.info(TAG + "setZoomRatio success: 5");
console.info(TAG + "getZoomRatio called")
var getpromise5 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise5);
if (getpromise5 != null && getpromise5 != undefined) {
expect(getpromise5).assertEqual(5);
console.info(TAG + "SET_GET_ZOOM_5_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_5_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_GET_ZOOM_6_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_6_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(6);
console.info(TAG + "setZoomRatio success: 6");
console.info(TAG + "getZoomRatio called")
var getpromise6 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise6);
if (getpromise6 != null && getpromise6 != undefined) {
expect(getpromise6).assertEqual(6);
console.info(TAG + "SET_GET_ZOOM_6_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_6_PROMISE FAILED");
expect().assertFail();
}
await sleep(1000);
done();
})
// FOCUS promise API's
/**
* @tc.number : IS_FOCUS_MODE_LOCKED_SUPPORTED
* @tc.name : check is focus mode locked supported-camera0Input api
* @tc.desc : check is focus mode locked supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED to operate");
var isFMLockedSupported = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering is focus mode locked supported SUCCESS ");
if (isFMLockedSupported != null || isFMLockedSupported != undefined) {
console.info(TAG + "Entering is focus mode locked supported data is not null || undefined");
console.info(TAG + "is focus mode locked supported : " + isFMLockedSupported);
expect(isFMLockedSupported).assertEqual(false);
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_LOCKED
* @tc.name : set focus mode locked camera0 api
* @tc.desc : set focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_LOCKED)
.then(function (data) {
console.info(TAG + "SetFMLocked: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode locked SUCCESS, current focusmode is: " + cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED FAILED : ")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED ends here");
});
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_LOCKED
* @tc.name : get focus mode locked camera0 api
* @tc.desc : get focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_LOCKED to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode locked success: ");
if (data == 0) {
console.info(TAG + "Current focusmode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_LOCKED PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_LOCKED ends here");
});
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCAL_LENGTH
* @tc.name : get focal length camera0 api
* @tc.desc : get focal length camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCAL_LENGTH', 0, async function (done) {
console.info(TAG + "Entering GET_FOCAL_LENGTH to operate");
await camera0InputPromise.getFocalLength()
.then(function (data) {
console.info(TAG + "Current focallength is: " + JSON.stringify(data));
expect(data).assertEqual(3.4600000381469727);
console.info(TAG + "GET_FOCAL_LENGTH PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCAL_LENGTH FAILED : " + err.message);
});
console.info(TAG + "GET_FOCAL_LENGTH ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point1)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is:" + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current FocusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_MANUAL_SUPPORTED
* @tc.name : is focusmode manual supported
* @tc.desc : is focusmode manual supported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_MANUAL_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED to operate");
var isFMmanualSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_MANUAL);
if (isFMmanualSupportedpromise != null || isFMmanualSupportedpromise != undefined) {
console.info(TAG + "Entering is focusmode manual supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_MANUAL_SUPPORTED is: " + isFMmanualSupportedpromise);
expect(isFMmanualSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_MANUAL
* @tc.name : set focus mode manual camera0 api
* @tc.desc : set focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL)
.then(function (data) {
console.info(TAG + "setFocusManual: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode manual SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_MANUAL);
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_MANUAL).assertEqual(0)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_MANUAL
* @tc.name : get focus mode manual camera0 api
* @tc.desc : get focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode manual SUCCESS");
if (data == 0) {
console.info(TAG + "Current FocusMode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_MANUAL PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_MANUAL FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_MANUAL ends here");
});
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputPromise.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point2)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current focusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_CONTINUOUS_SUPPORTED
* @tc.name : check is focus mode continuous supported-camera0Input api
* @tc.desc : check is focus mode continuous supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_CONTINUOUS_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED to operate");
var isFMContinuousSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
if (isFMContinuousSupportedpromise != null || isFMContinuousSupportedpromise != undefined) {
console.info(TAG + "Entering is focus mode continuous supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_CONTINUOUS_SUPPORTED is: " + isFMContinuousSupportedpromise);
expect(isFMContinuousSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_CONTINUOUS
* @tc.name : set focus mode continuous camera0 api
* @tc.desc : set focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO)
.then(function (data) {
console.info(TAG + "setFocusCont: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode continuous SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO).assertEqual(1)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_CONTINUOUS
* @tc.name : get focus mode continuous camera0 api
* @tc.desc : get focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode continuous SUCCESS");
if (data == 1) {
console.info(TAG + "Current FocusMode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS FAILED: " + err.message);
});
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputPromise.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point3)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is:" + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current FocusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_AUTO_SUPPORTED
* @tc.name : check is focus mode auto supported-camera0Input api
* @tc.desc : check is focus mode auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED to operate");
var isFMAutoSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO);
if (isFMAutoSupportedpromise != null || isFMAutoSupportedpromise != undefined) {
console.info(TAG + "Entering is focus mode auto supported data is not null || undefined");
console.info(TAG + "is focus mode auto supported is: " + isFMAutoSupportedpromise);
expect(isFMAutoSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_AUTO
* @tc.name : set focus mode auto camera0 api
* @tc.desc : set focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO to operate");
var setFocusAuto = await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_AUTO)
.then(function () {
console.info(TAG + "setFocusAuto: " + JSON.stringify(setFocusAuto))
console.info(TAG + "Entering set focus mode auto SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_AUTO);
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_AUTO).assertEqual(2)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_AUTO
* @tc.name : get focus mode auto camera0 api
* @tc.desc : get focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode auto SUCCESS " + JSON.stringify(data));
if (data == 2) {
console.info(TAG + "Current FocusMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_AUTO PASSED");
}
})
.catch((err) => {
console.info(TAG + "GET_FOCUS_MODE_AUTO FAILED : ");
console.info(TAG + "GET_FOCUS_MODE_AUTO ends here");
});
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputPromise.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : IS_EXPOSURE_MODE_LOCKED_SUPPORTED
* @tc.name : check is exposure mode locked supported-camera0Input api
* @tc.desc : check is exposure mode locked supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED PASSED: " + data);
expect(data).assertEqual(false);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_LOCKED
* @tc.name : set exposure mode locked camera0 api
* @tc.desc : set exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_Locked to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED);
console.info(TAG + "Entering SET_EXPOSURE_MODE_Locked FAILED")
expect().assertFail()
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_LOCKED
* @tc.name : get exposure mode locked camera0 api
* @tc.desc : get exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_LOCKED to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode locked SUCCESS");
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED ends here");
await sleep(1000);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED
* @tc.name : check is exposure mode continuous auto supported-camera0Input api
* @tc.desc : check is exposure mode continuous auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED PASSED: " + data);
expect(data).assertEqual(false);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : set exposure mode continuous auto camera0 api
* @tc.desc : set exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : get exposure mode continuous auto camera0 api
* @tc.desc : get exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode auto SUCCESS");
console.info(TAG + "Current exposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_RANGE
* @tc.name : get exposure bias range camera0 api
* @tc.desc : get exposure bias range camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_RANGE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_RANGE to operate");
await camera0InputPromise.getExposureBiasRange()
.then(function (data) {
console.info(TAG + "Entering getExposureBiasRange SUCCESS");
console.info(TAG + "Current ExposureBiasRange is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_BIAS_RANGE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_RANGE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_RANGE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_-4
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(-4)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + "-4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
await camera0InputPromise.setExposurePoint(Point1)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED: " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_AUTO_SUPPORTED
* @tc.name : check is exposure mode auto supported-camera0Input api
* @tc.desc : check is exposure mode auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED PASSED: " + data);
expect(data).assertEqual(true);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED FAILED: " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_AUTO
* @tc.name : set exposure mode auto camera0 api
* @tc.desc : set exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO PASSED")
expect(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO).assertEqual(1);
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_AUTO
* @tc.name : get exposure mode auto camera0 api
* @tc.desc : get exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('GET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_AUTO to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode auto SUCCESS");
console.info(TAG + "Current exposureMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_AUTO FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_AUTO ends here");
await sleep(1000);
done();
})
*/
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputPromise.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1000);
done();
})
await sleep(1000);
done();
}
})
/**
* @tc.number : SET_EXPOSURE_BIAS
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(1)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + "1");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
await camera0InputPromise.setExposurePoint(Point2)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS Rotation-0 & Quality-0
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS1', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS to operate");
await photoOutputPromise.capture(photosettings1)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with Rotation-0 & Quality-0 success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings1 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS Rotation-0 & Quality-0 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS Rotation-0 & Quality-0 FAILED:" + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS Rotation-0 & Quality-0 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(4)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + "4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
await camera0InputPromise.setExposurePoint(Point3)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2
* @tc.name : Photo output capture with photosettings api
* @tc.desc : Photo output capture with photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS to operate");
await photoOutputPromise.capture(photosettings2)
.then(function (data) {
console.info(TAG + "Entering photoOutput capture with location settings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture with photosettings2 data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 PASSED");
expect(true).assertTrue();
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITH_PHOTOSETTINGS2 ends here");
});
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_-5
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(-5)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + "-4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE ends here");
await sleep(1000);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_6
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(6)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + "4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1000);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIAS_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIAS_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIAS_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIAS_VALUE ends here");
await sleep(1000);
done();
})
/*CaptureSession APIs test script*/
/**
* @tc.number : CAPTURE_SESSION_STOP_SUCCESS_PROMISE
* @tc.name : capture session stop api
* @tc.desc : capture session stop api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_STOP_SUCCESS_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering capture session stop captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_STOP_SUCCESS_PROMISE to operate");
await CaptureSessionPromise.stop();
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_STOP_SUCCESS_PROMISE captureSession.stop PASSED");
console.info(TAG + "Entering CAPTURE_SESSION_STOP_SUCCESS_PROMISE captureSession.stop ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : CAPTURE_SESSION_RELEASE_SUCCESS_PROMISE
* @tc.name : capture session release api
* @tc.desc : capture session release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (CaptureSessionPromise == null || CaptureSessionPromise == undefined) {
console.info(TAG + "Entering capture session release captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE_SUCCESS_PROMISE to operate");
await CaptureSessionPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering CAPTURE_SESSION_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : PreviewOutput release api
* @tc.desc : PreviewOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering previewOutputPromise.release previewOutputPromise == null || undefined");
} else {
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE to operate");
await previewOutputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : PHOTOOUTPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : PhotoOutput release api
* @tc.desc : PhotoOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering PhotoOutput release photoOutputPromise == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_RELEASE_SUCCESS_PROMISE to operate");
await photoOutputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering PHOTOOUTPUT_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering PHOTOOUTPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
/**
* @tc.number : CAMERAINPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : cameraInput release api
* @tc.desc : cameraInput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERAINPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering cameraInput release camera0InputPromise == null || undefined");
} else {
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISE to operate");
await camera0InputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISEPASSED");
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1000);
done();
}
await sleep(1000);
done();
})
});
}
\ No newline at end of file
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/test/CameraJSUnitVideoAsync.test.ets 已删除 100644 → 0
浏览文件 @ 119f5fb2
/*
* Copyright (C) 2022 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 cameraObj from '@ohos.multimedia.camera';
import media from '@ohos.multimedia.media'
import image from '@ohos.multimedia.image';
import mediaLibrary from '@ohos.multimedia.mediaLibrary'
import fileio from '@ohos.fileio';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
import bundle from '@ohos.bundle'
// @ts-nocheck
import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index';
let TAG = "CameraModuleTest: ";
var cameraManager
var camerasArray
var camera0Input
var previewOutput
var photoOutputAsync
var videoRecorder
var surfaceId1
var minFrameRate_Grp0=12;
var maxFrameRate_Grp0=12;
var minFrameRate_Mix=14;
var maxFrameRate_Mix=15;
var minFrameRate_Err1=11;
var maxFrameRate_Err1=31;
var minFrameRate_Err2=14;
var maxFrameRate_Err2=28;
var minFrameRate_Err3=16;
var maxFrameRate_Err3=25;
var minFrameRate_Grp20=30;
var maxFrameRate_Grp20=30;
var Point = { x: 1, y: 1 }
var photosettings1 = {
rotation: 0,
quality: 0,
location: {
latitude: 12.9705,
longitude: 77.7329,
altitude: 920.0000,
},
}
var photosettings2 = {
rotation: 90,
quality: 1,
location: {
latitude: 20,
longitude: 78,
altitude: 8586,
},
}
var photosettings3 = {
quality: 2,
location: {
latitude: 0,
longitude: 0,
altitude: 0,
},
}
var photosettings4 = {
rotation: 180,
location: {
latitude: -1,
longitude: -1,
altitude: -1,
},
}
let fdPath;
let fileAsset;
let fdNumber;
let configFile = {
audioBitrate: 48000,
audioChannels: 2,
audioCodec: 'audio/mp4a-latm',
audioSampleRate: 48000,
durationTime: 1000,
fileFormat: 'mp4',
videoBitrate: 48000,
videoCodec: 'video/mp4v-es',
videoFrameWidth: 640,
videoFrameHeight: 480,
videoFrameRate: 30
}
let videoConfig = {
audioSourceType: 1,
videoSourceType: 0,
profile: configFile,
url: 'file:///data/media/02.mp4',
orientationHint: 0,
location: { latitude: 30, longitude: 130 },
maxSize: 100,
maxDuration: 500
}
var videoId
var videoOutput
var captureSession
export default function cameraJSUnitVideoAsync(surfaceId: any) {
async function getImageReceiverSurfaceId() {
console.log(TAG + 'Entering create Image receiver')
var receiver = image.createImageReceiver(640, 480, 4, 8)
console.log(TAG + 'before receiver check')
if (receiver !== undefined) {
console.log(TAG + 'Receiver is ok')
surfaceId1 = await receiver.getReceivingSurfaceId()
console.log(TAG + 'Received id: ' + JSON.stringify(surfaceId1))
} else {
console.log(TAG + 'Receiver is not ok')
}
}
function sleep(time) {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(1)
}, time * 1000)
}).then(() => {
console.info(`sleep ${time} over...`)
})
}
async function applyPermission() {
let appInfo = await bundle.getApplicationInfo('com.open.harmony.multimedia.cameratest', 0, 100);
let atManager = abilityAccessCtrl.createAtManager();
if (atManager != null) {
let tokenID = appInfo.accessTokenId;
console.info('[permission] case accessTokenID is ' + tokenID);
let permissionName1 = 'ohos.permission.CAMERA';
let permissionName2 = 'ohos.permission.MICROPHONE';
let permissionName3 = 'ohos.permission.MEDIA_LOCATION';
let permissionName4 = 'ohos.permission.READ_MEDIA';
let permissionName5 = 'ohos.permission.WRITE_MEDIA';
await atManager.grantUserGrantedPermission(tokenID, permissionName1, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName2, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName3, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName4, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName5, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
} else {
console.info('[permission] case apply permission failed, createAtManager failed');
}
}
async function getFd(pathName) {
let displayName = pathName;
const mediaTest = mediaLibrary.getMediaLibrary();
let fileKeyObj = mediaLibrary.FileKey;
let mediaType = mediaLibrary.MediaType.VIDEO;
let publicPath = await mediaTest.getPublicDirectory(mediaLibrary.DirectoryType.DIR_VIDEO);
let dataUri = await mediaTest.createAsset(mediaType, displayName, publicPath);
if (dataUri != undefined) {
let args = dataUri.id.toString();
let fetchOp = {
selections: fileKeyObj.ID + "=?",
selectionArgs: [args],
}
let fetchFileResult = await mediaTest.getFileAssets(fetchOp);
fileAsset = await fetchFileResult.getAllObject();
fdNumber = await fileAsset[0].open('Rw');
fdPath = "fd://" + fdNumber.toString();
}
}
async function closeFd() {
if (fileAsset != null) {
await fileAsset[0].close(fdNumber).then(() => {
console.info('[mediaLibrary] case close fd success');
}).catch((err) => {
console.info('[mediaLibrary] case close fd failed');
});
} else {
console.info('[mediaLibrary] case fileAsset is null');
}
}
async function getvideosurface() {
await getFd('02.mp4');
videoConfig.url = fdPath;
media.createVideoRecorder((err, recorder) => {
console.info(TAG + 'createVideoRecorder called')
videoRecorder = recorder
console.info(TAG + 'videoRecorder is :' + JSON.stringify(videoRecorder))
console.info(TAG + 'videoRecorder.prepare called.')
videoRecorder.prepare(videoConfig, (err) => {
console.info(TAG + 'videoRecorder.prepare success.')
})
videoRecorder.getInputSurface((err, id) => {
console.info(TAG + 'getInputSurface called')
videoId = id
console.info(TAG + 'getInputSurface surfaceId: ' + JSON.stringify(videoId))
})
})
}
describe('VideoModeAsync', function () {
console.info(TAG + '----------Camera-VideoMode-Async--------------')
beforeAll(async function () {
await applyPermission();
console.info('beforeAll case');
})
beforeEach(function () {
sleep(5);
console.info('beforeEach case');
})
afterEach(async function () {
await closeFd();
console.info('afterEach case');
})
afterAll(function () {
console.info('afterAll case');
})
/**
* @tc.number : GET_CAMERA_MANAGER_TC
* @tc.name : Create camera manager instance async api
* @tc.desc : Create camera manager instance async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERA_MANAGER_TC', 0, async function (done) {
console.info('--------------GET_CAMERA_MANAGER_TC--------------')
await sleep(1)
cameraObj.getCameraManager(null, (err, data) => {
if (!err) {
console.info(TAG + 'Entering Get Camera manager success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering Get Camera Manager data is not null || undefined')
cameraManager = data
expect(true).assertTrue()
console.info(TAG + 'Entering GET_CAMERA_MANAGER_TC PASSED')
}
} else {
expect().assertFail()
console.info(TAG + 'Entering GET_CAMERA_MANAGER_TC FAILED: ' + err.message)
}
console.info(TAG + 'Entering GET_CAMERA_MANAGER_TC ends here')
done()
})
await sleep(1)
done()
})
/**
* @tc.number : CAMERA_STATUS_CALLBACK
* @tc.name : camera status callback on CameraManager async api
* @tc.desc : camera status callback on CameraManager async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_STATUS_CALLBACK', 0, async function (done) {
if (cameraManager == null || cameraManager == undefined) {
console.info(TAG + 'Entering CAMERA_STATUS_CALLBACK cameraManager == null || undefined')
} else {
console.info(TAG + 'Entering CAMERA_STATUS_CALLBACK to operate')
cameraManager.on('cameraStatus', async (err, data) => {
if (!err) {
console.info(TAG + "Camera status Callback on cameraManager is success");
if (data != null || data != undefined) {
console.info(TAG + "Camera status Callback CameraStatusInfo_Camera: " + data.camera);
console.info(TAG + "Camera status Callback CameraStatusInfo_Status: " + data.status);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Camera status Callback FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : GET_CAMERAS
* @tc.name : Create camera manager instance async api
* @tc.desc : Create camera manager instance async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERAS', 0, async function (done) {
console.info('--------------GET_CAMERAS--------------')
await sleep(1)
cameraManager.getCameras((err, data) => {
if (!err) {
console.info(TAG + 'Entering Get Cameras success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering Get Cameras data is not null || undefined')
camerasArray = data
if (camerasArray != null && camerasArray.length > 0) {
for (var i = 0; i < camerasArray.length; i++) {
// Get the variables from camera object
var cameraId = camerasArray[i].cameraId
console.info(TAG + 'Entering Get Cameras camera' + i + 'Id: ' + cameraId)
var cameraPosition = camerasArray[i].cameraPosition
console.info(TAG + 'Entering Get Cameras camera' + i + 'Position: ' + cameraPosition)
var cameraType = camerasArray[i].cameraType
console.info(TAG + 'Entering Get Cameras camera' + i + 'Type: ' + cameraType)
var connectionType = camerasArray[i].connectionType
console.info(TAG + 'Entering Get Cameras connection' + i + 'Type: ' + connectionType)
}
expect(true).assertTrue()
console.info(TAG + 'Entering GET_CAMERAS PASSED')
} else {
expect().assertFail()
console.info(TAG + 'Entering GET_CAMERAS FAILED cameraArray is null || undefined')
}
}
} else {
expect().assertFail()
console.info(TAG + 'Entering GET_CAMERAS FAILED: ' + err.message)
}
console.info(TAG + 'Entering GET_CAMERAS ends here')
done()
})
await sleep(1)
done()
})
/*CAMERA-0 Scripts*/
/**
* @tc.number : CREATE_CAMERA_INPUT
* @tc.name : Create camerainput from camera-0 cameraId async api
* @tc.desc : Create camerainput from camera-0 cameraId async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT', 0, async function (done) {
console.info('--------------CAMERA-0 STARTS HERE--------------')
console.info('--------------CREATE_CAMERA_INPUT--------------')
await sleep(1)
cameraManager.createCameraInput(camerasArray[0].cameraId, (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + 'Entering Create camera input data is not null || undefined')
camera0Input = data
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_CAMERA_INPUT PASSED with CameraID :' + camerasArray[0].cameraId)
}
} else {
expect().assertFail()
console.info(TAG + 'Entering CREATE_CAMERA_INPUT FAILED: ' + err.message)
}
console.info(TAG + 'Entering CREATE_CAMERA_INPUT ends here')
done()
})
await sleep(1)
done()
})
/**
* @tc.number : CAMERA_INPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_INPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering Camera Input callback camera0Input == null || undefined");
} else {
console.info(TAG + "Entering CAMERA_INPUT_CALLBACK_ON_ERROR to operate");
camera0Input.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "camera0Input error callback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CREATE_PREVIEW_OUTPUT
* @tc.name : Create previewoutput async api
* @tc.desc : Create previewoutput async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PREVIEW_OUTPUT', 0, async function (done) {
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT to operate')
await sleep(1)
cameraObj.createPreviewOutput(surfaceId, (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create preview output success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering Create preview output data is not null || undefined')
previewOutput = data
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT PASSED')
}
} else {
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT ends here')
done()
})
await sleep(1)
done()
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Preview output callback on error api
* @tc.desc : Preview output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (previewOutput == null || previewOutput == undefined) {
console.info(TAG + "Entering PreviewOutput callback on error previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_ERROR to operate");
previewOutput.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PreviewOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/*PhotoOutput APIs test script*/
/**
* @tc.number : CREATE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Create PhotoOutput instance api
* @tc.desc : Create PhotoOutput instance api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS to operate");
console.info(TAG + 'Entering getImageReceiverSurfaceId')
await getImageReceiverSurfaceId()
await sleep(1)
cameraObj.createPhotoOutput(surfaceId1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering createPhotoOutput success");
if (data != null || data != undefined) {
console.info(TAG + "Entering createPhotoOutput data is not null || undefined");
photoOutputAsync = data;
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS FAILED : " + err.message);
console.info(TAG + "Entering createPhotoOutput ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : PHOTO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR to operate");
photoOutputAsync.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PhotoOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Error during PhotoOutput with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CREATE_VIDEO_OUTPUT
* @tc.name : Create videooutput async api
* @tc.desc : Create videooutput async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_VIDEO_OUTPUT', 0, async function (done) {
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT to operate')
await getvideosurface()
await sleep(2)
cameraObj.createVideoOutput(videoId, (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create videooutput success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering Create videooutput data is not null || undefined')
videoOutput = data
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT PASSED')
}
} else {
expect().assertFail()
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT FAILED: ' + err.message)
}
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT ends here')
done()
})
await sleep(1)
done()
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : VideoOutput callback onerror async api
* @tc.desc : VideoOutput callback onerror async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_ERROR videoOutput == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_ERROR to operate')
await sleep(1)
videoOutput.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "VideoOutput Errorcallback is success")
if (data != null || data != undefined) {
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue()
}
} else {
expect().assertFail()
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1)
done()
})
await sleep(1)
done();
}
})
/**
* @tc.number : CREATE_CAPTURE_SESSION
* @tc.name : Create capturesession async api
* @tc.desc : Create capturesession async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAPTURE_SESSION', 0, async function (done) {
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION to operate')
await sleep(1)
cameraObj.createCaptureSession(null, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create capturesession success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering Create capturesession data is not null || undefined')
captureSession = data
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION PASSED')
}
} else {
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
/**
* @tc.number : CAP_SES_CALLBACK_ON_ERROR
* @tc.name : CaptureSession callback on error api
* @tc.desc : CaptureSession callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAP_SES_CALLBACK_ON_ERROR', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CAP_SES_CALLBACK_ON_ERROR captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAP_SES_CALLBACK_ON_ERROR to operate");
captureSession.on('error', async (err, data) => {
if (!err) {
console.info(TAG + " captureSession errorcallback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : BEGIN_CONFIG
* @tc.name : Begin Config async api
* @tc.desc : Begin Config async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('BEGIN_CONFIG', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering Begin Config captureSession == null || undefined')
} else {
console.info(TAG + 'Entering BEGIN_CONFIG to operate')
await sleep(1)
captureSession.beginConfig((err, data) => {
if (!err) {
console.info(TAG + 'Entering Begin Config success')
expect(true).assertTrue()
console.info(TAG + 'Entering BEGIN_CONFIG PASSED')
} else {
console.info(TAG + 'Entering BEGIN_CONFIG FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering BEGIN_CONFIG ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : ADD_INPUT
* @tc.name : AddInput async api
* @tc.desc : AddInput async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddInput captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_INPUT to operate')
await sleep(1)
captureSession.addInput(camera0Input, (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddInput success')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_INPUT PASSED')
} else {
console.info(TAG + 'Entering ADD_INPUT FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_INPUT ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW
* @tc.name : AddOutput preview async api
* @tc.desc : AddOutput preview async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddOutput preview captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW to operate')
await sleep(1)
captureSession.addOutput(previewOutput, (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddOutput preview success')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW PASSED')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Photo captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
captureSession.addOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Photo success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Photo data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED: " + err.message);
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : ADD_OUTPUT_VIDEO
* @tc.name : AddOutput video async api
* @tc.desc : AddOutput video async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_VIDEO', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddOutput video captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO to operate')
await sleep(1)
captureSession.addOutput(videoOutput, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddOutput video success')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO PASSED')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO ends here')
await sleep(1);
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : REMOVE_INPUT_SUCCESS
* @tc.name : remove input api
* @tc.desc : remove input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_INPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
captureSession.removeInput(camera0Input, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove input success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering Remove Input FAILED" + err.message);
console.info(TAG + "Entering Remove Input ends here");
}
await sleep(1);
done();
})
await sleep(1);
}
done();
})
/**
* @tc.number : REMOVE_PREVIEW_OUTPUT_SUCCESS
* @tc.name : Remove preview Output api
* @tc.desc : Remove preview Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PREVIEW_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS to operate");
captureSession.removeOutput(previewOutput, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove preview Output success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering Remove preview Output FAILED" + err.message);
console.info(TAG + "Entering Remove Preview Output ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : REMOVE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Remove photo Output api
* @tc.desc : Remove photo Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS to operate");
captureSession.removeOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove photo Output success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_PHOTO_OUTPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering Remove photo Output FAILED" + err.message);
console.info(TAG + "Entering Remove photo Output ends here");
}
await sleep(1);
done();
})
await sleep(1);
}
done();
})
/**
* @tc.number : REMOVE_VIDEO_OUTPUT_SUCCESS
* @tc.name : Remove video Output api
* @tc.desc : Remove video Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_VIDEO_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS to operate");
captureSession.removeOutput(videoOutput, async (err, data) => {
if (!err) {
console.info(TAG + "Entering remove video Output success");
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering Remove video Output FAILED" + err.message);
console.info(TAG + "Entering Remove video Output ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : ADD_INPUT
* @tc.name : AddInput async api
* @tc.desc : AddInput async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddInput captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_INPUT to operate')
await sleep(1)
captureSession.addInput(camera0Input, (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddInput success')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_INPUT PASSED')
} else {
console.info(TAG + 'Entering ADD_INPUT FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_INPUT ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW
* @tc.name : AddOutput preview async api
* @tc.desc : AddOutput preview async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddOutput captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW to operate')
await sleep(1)
captureSession.addOutput(previewOutput, (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddOutput success')
console.info(TAG + 'Entering AddOutput data is not null || undefined')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW PASSED')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_OUTPUT_PREVIEW ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : ADD_OUTPUT_PHOTO
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering AddOutput_Photo captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO to operate");
captureSession.addOutput(photoOutputAsync, async (err, data) => {
if (!err) {
console.info(TAG + "Entering AddOutput_Photo success");
if (data != null || data != undefined) {
console.info(TAG + "Entering AddOutput_Photo data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO FAILED: " + err.message);
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO ends here");
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : ADD_OUTPUT_VIDEO
* @tc.name : AddOutput video async api
* @tc.desc : AddOutput video async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_VIDEO', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering AddOutput captureSession == null || undefined')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO to operate')
await sleep(1)
captureSession.addOutput(videoOutput, (err, data) => {
if (!err) {
console.info(TAG + 'Entering AddOutput success')
console.info(TAG + 'Entering AddOutput data is not null || undefined')
expect(true).assertTrue()
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO PASSED')
} else {
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering ADD_OUTPUT_VIDEO ends here')
done()
})
await sleep(1)
done()
}
})
//framerate
/**
* @tc.number : GET_FRAME_RATE_RANGE
* @tc.name : get frame rate range camera0 api
* @tc.desc : get frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FRAME_RATE_RANGE', 0, async function (done) {
console.info(TAG + "Entering GET_FRAME_RATE_RANGE to operate");
videoOutput.getFrameRateRange(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get frame rate range success");
expect(true).assertTrue();
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
console.info(TAG + "GET_FRAME_RATE_RANGE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FRAME_RATE_RANGE FAILED : " + err.message);
console.info(TAG + "GET_FRAME_RATE_RANGE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Grp0
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Grp0', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp0 to operate");
videoOutput.setFrameRateRange(minFrameRate_Grp0,maxFrameRate_Grp0, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range PASSED")
expect(true).assertTrue();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp0 FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp0 ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Mix
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Mix', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Mix to operate");
videoOutput.setFrameRateRange(minFrameRate_Mix,maxFrameRate_Mix, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range FAILED")
expect().assertFail();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Mix PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Mix ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err1
* @tc.name : set frame rate range camera0 api_err
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err1', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err1 to operate");
videoOutput.setFrameRateRange(minFrameRate_Err1,maxFrameRate_Err1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range FAILED")
expect().assertFail();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err1 PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err1 ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err2
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err2', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err2 to operate");
videoOutput.setFrameRateRange(minFrameRate_Err2,maxFrameRate_Err2, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range FAILED");
expect().assertFail();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err2 PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err2 ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err3
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err3', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err3 to operate");
videoOutput.setFrameRateRange(minFrameRate_Err3,maxFrameRate_Err3, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range FAILED");
expect().assertFail();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err3 PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err3 ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Grp20
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Grp20', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp20 to operate");
videoOutput.setFrameRateRange(minFrameRate_Grp20,maxFrameRate_Grp20, async (err, data) => {
if (!err) {
console.info(TAG + "Entering set frame rate range, current framerateRange is: " + JSON.stringify(data));
console.info(TAG + "Entering set frame rate range PASSED")
expect(true).assertTrue();
}
else {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp20 FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp20 ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTEDOFF
* @tc.name : isVideoStabilizationModeSupported Off
* @tc.desc : isVideoStabilizationModeSupported async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTEDOFF', 0, async function (done) {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF to operate')
captureSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.OFF, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create isVideoStabilizationModeSupported success')
expect(data).assertEqual(true)
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF PASSED :' + data)
}
else {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEOFF
* @tc.name : SetVideoStabilizationModeOff
* @tc.desc : SetVideoStabilizationModeOff async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEOFF', 0, async function (done) {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEOFF to operate')
captureSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.OFF, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Set VideoStabilization Mode Off success')
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEOFF PASSED: ' + data)
expect(cameraObj.VideoStabilizationMode.OFF).assertEqual(0)
}
else {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEOFF FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEOFF ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATION_MODE_OFF
* @tc.name : getVideoStabilizationModeOff
* @tc.desc : getVideoStabilizationModeOff async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATION_MODE_OFF', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATION_MODE_OFF to operate");
captureSession.getActiveVideoStabilizationMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get Video Stabilization Mode Off success");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_OFF PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_OFF FAILED :" + err.message);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_OFF ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_LOW
* @tc.name : is VideoStabilization Mode Low Supported
* @tc.desc : isVideoStabilizationModeSupported low async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_LOW', 0, async function (done) {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW to operate')
captureSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.LOW, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering isVideoStabilizationModeSupported success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering isVideoStabilizationModeSupported data is not null || undefined')
expect(data).assertEqual(true)
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW PASSED: ' + data)
}
} else {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODELOW
* @tc.name : SetVideoStabilizationModelow
* @tc.desc : SetVideoStabilizationModelow async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODELOW', 0, async function (done) {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODELOW to operate')
captureSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.LOW, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Set VideoStabilization Mode Low success')
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODELOW PASSED: ' + data)
expect(cameraObj.VideoStabilizationMode.LOW).assertEqual(1);
}
else {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODELOW FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODELOW ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATION_MODE_LOW
* @tc.name : getVideoStabilizationModeLow
* @tc.desc : getVideoStabilizationModeLOw async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('GET_VIDEOSTABILIZATION_MODE_LOW', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATION_MODE_LOW to operate");
captureSession.getActiveVideoStabilizationMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get Video Stabilization Mode low success");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(data).assertEqual(1)
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_LOW PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_LOW FAILED :" + err.message);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_LOW ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE
* @tc.name : is VideoStabilization Mode Middle Supported
* @tc.desc : isVideoStabilizationModeSupported Middle async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE', 0, async function (done) {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE to operate')
captureSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.MIDDLE, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering is VideoStabilization Mode middle Supported success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering isVideoStabilizationModeSupported data is not null || undefined')
expect(data).assertEqual(false)
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE PASSED : ' + data)
}
} else {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEMIDDLE
* @tc.name : SetVideoStabilizationModeMedium
* @tc.desc : SetVideoStabilizationModeMedium async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEMIDDLE', 0, async function (done) {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEMIDDLE to operate')
captureSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.MIDDLE, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create Set VideoStabilization Mode middle success')
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEMIDDLE FAILED: ' + data)
expect().assertFail();
}
else {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEMIDDLE PASSED: ' + err.message)
expect(true).assertTrue();
}
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEMIDDLE ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATION_MODE_MIDDLE
* @tc.name : getVideoStabilizationModeMedium
* @tc.desc : getVideoStabilizationModeMedium async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATION_MODE_MIDDLE', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATION_MODE_MIDDLE to operate");
captureSession.getActiveVideoStabilizationMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get Video Stabilization Mode medium success");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_MIDDLE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_MIDDLE FAILED :" + err.message);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_MIDDLE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH
* @tc.name : is VideoStabilization Mode High Supported
* @tc.desc : isVideoStabilizationModeSupported High async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH', 0, async function (done) {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH to operate')
captureSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.HIGH, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering is VideoStabilization Mode High Supported success')
expect(data).assertEqual(false)
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH PASSED : ' + data)
}
else {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEHIGH
* @tc.name : SetVideoStabilizationModeHigh
* @tc.desc : SetVideoStabilizationModeHigh async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEHIGH', 0, async function (done) {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEHIGH to operate')
captureSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.HIGH, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create Set VideoStabilization Mode High success')
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEHIGH FAILED: ' + data)
expect().assertFail();
}
else {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEHIGH PASSED: ' + err.message)
expect(true).assertTrue();
}
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEHIGH ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATION_MODE_HIGH
* @tc.name : getVideoStabilizationModeHigh
* @tc.desc : getVideoStabilizationModeHigh async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATION_MODE_HIGH', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATION_MODE_HIGH to operate");
captureSession.getActiveVideoStabilizationMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get Video Stabilization Mode High success");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_HIGH PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_HIGH FAILED :" + err.message);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_HIGH ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO
* @tc.name : is VideoStabilization Mode Auto Supported
* @tc.desc : isVideoStabilizationModeSupported Auto async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO', 0, async function (done) {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO to operate')
captureSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.AUTO, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering is VideoStabilization Mode Auto Supported success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering isVideoStabilizationModeSupported data is not null || undefined')
expect(data).assertEqual(false)
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO PASSED : ' + data)
}
} else {
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO FAILED: ' + err.message)
expect().assertFail()
}
console.info(TAG + 'Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEAUTO
* @tc.name : SetVideoStabilizationModeAuto
* @tc.desc : SetVideoStabilizationModeAuto async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEAUTO', 0, async function (done) {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEAUTO to operate')
captureSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.AUTO, async (err, data) => {
if (!err) {
console.info(TAG + 'Entering Create Set VideoStabilization Mode auto success')
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEAUTO FAILED: ' + data)
expect().assertFail();
}
else {
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEAUTO PASSED: ' + err.message)
expect(true).assertTrue();
}
console.info(TAG + 'Entering SET_VIDEOSTABILIZATIONMODEAUTO ends here')
await sleep(1)
done()
})
await sleep(1)
done()
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATION_MODE_AUTO
* @tc.name : getVideoStabilizationModeAuto
* @tc.desc : getVideoStabilizationModeAuto async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATION_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATION_MODE_AUTO to operate");
captureSession.getActiveVideoStabilizationMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering get Video Stabilization Mode Auto success");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_AUTO FAILED :" + err.message);
console.info(TAG + "GET_VIDEOSTABILIZATION_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : COMMIT_CONFIG
* @tc.name : CommitConfig async api
* @tc.desc : CommitConfig async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering CommitConfig captureSession == null || undefined')
} else {
console.info(TAG + 'Entering COMMIT_CONFIG to operate')
await sleep(1)
captureSession.commitConfig(async (err, data) => {
if (!err) {
console.info(TAG + 'Entering CommitConfig success')
console.info(TAG + 'Entering CommitConfig data is not null || undefined')
expect(true).assertTrue()
console.info(TAG + 'Entering COMMIT_CONFIG PASSED')
} else {
console.info(TAG + 'Entering COMMIT_CONFIG FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering COMMIT_CONFIG ends here')
await sleep(1)
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : FocusStateChange callback api
* @tc.desc : FocusStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering FocusStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0Input.on('focusStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "FocusState callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current FocusState is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : ExposureStateChange callback api
* @tc.desc : ExposureStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering ExposureStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0Input.on('exposureStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "ExposureStateChange callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current ExposureStateChange is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
//callback API
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : Preview output callback on frame start api
* @tc.desc : Preview output callback on frame start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (previewOutput == null || previewOutput == undefined) {
console.info(TAG + "Entering Preview output callback on frame start previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START to operate");
previewOutput.on('frameStart', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START FAILED : + err.message");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : Preview capture callback on frame end api
* @tc.desc : Preview capture callback on frame end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (previewOutput == null || previewOutput == undefined) {
console.info(TAG + "Entering Preview capture callback on frame end previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END to operate");
previewOutput.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END FAILED : + err.message");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
//Capture callback
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_START
* @tc.name : Photo capture callback on capture start api
* @tc.desc : Photo capture callback on capture start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_START', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering Photo Capture Callback on CaptureStart photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_START to operate");
photoOutputAsync.on('captureStart', async (err, data) => {
if (!err) {
console.info(TAG + "Photo Capture Callback on CaptureStart is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START with captureId: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_END
* @tc.name : Photo capture callback on capture end api
* @tc.desc : Photo capture callback on capture end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_END', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END to operate");
photoOutputAsync.on('captureEnd', async (err, data) => {
if (!err) {
console.info(TAG + "captureEnd callback is success");
if (data != null || data != undefined) {
console.info(TAG + "captureEnd callback with captureId: " + data.captureId);
console.info(TAG + "captureEnd callback with frameCount: " + data.frameCount);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + 'PHOTO_CAP_CALLBACK_ON_CAPTURE_END FAILED' + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER
* @tc.name : Photo capture callback on frame shutter api
* @tc.desc : Photo capture callback on frame shutter api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER to operate");
photoOutputAsync.on('frameShutter', async (err, data) => {
if (!err) {
console.info(TAG + "frameShutter callback is success");
if (data != null || data != undefined) {
console.info(TAG + "frameShutter callback with captureId: " + data.captureId);
console.info(TAG + "frameShutter callback with timestamp: " + data.timestamp);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : VideoOutput callback onframestart async api
* @tc.desc : VideoOutput callback onframestart async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + "Entering VideoOutput callback onframestart videoOutput == null || undefined");
} else {
console.info(TAG + "Entering VIDEO_OUTPUT_CALLBACK_ON_FRAME_START to operate");
videoOutput.on('frameStart', async (err, data) => {
if (!err) {
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_FRAME_START is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_FRAME_START is FAILED : " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : VideoOutput callback onframeend async api
* @tc.desc : VideoOutput callback onframeend async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + 'Entering VideoOutput callback onframeend videoOutput == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_FRAME_END to operate')
await sleep(1)
videoOutput.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + 'VIDEO_OUTPUT_CALLBACK_ON_FRAME_END is success');
if (data != null || data != undefined) {
expect(true).assertTrue()
}
} else {
expect().assertFail();
console.info(TAG + 'VIDEO_OUTPUT_CALLBACK_ON_FRAME_END FAILED' + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CAPTURE_SESSION_START
* @tc.name : CaptureSession start async api
* @tc.desc : CaptureSession start async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_START', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + "Entering CaptureSession start captureSession == null || undefined")
} else {
console.info(TAG + "Entering CAPTURE_SESSION_START to operate")
await sleep(1)
captureSession.start(async (err, data) => {
if (!err) {
console.info(TAG + "Entering CaptureSession start success")
expect(true).assertTrue()
console.info(TAG + "Entering CAPTURE_SESSION_START PASSED")
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_START FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering CAPTURE_SESSION_START ends here')
await sleep(1)
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS
* @tc.name : Photo output capture without photosettings api
* @tc.desc : Photo output capture without photosettings api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS to operate");
photoOutputAsync.capture(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutput capture without photosettings success");
if (data != null || data != undefined) {
console.info(TAG + "Entering photoOutput capture without photosettings data is not null || undefined");
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS PASSED");
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS FAILED : " + err.message);
console.info(TAG + "Entering PHOTOOUTPUT_CAPTURE_WITHOUT_PHOTOSETTINGS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
//FLASH Function API scripts
/**
* @tc.number : HAS_FLASH
* @tc.name : check if has flash-camera0Input api
* @tc.desc : check if has flash-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('HAS_FLASH', 0, async function (done) {
console.info(TAG + "hasFlash called.")
camera0Input.hasFlash(async (err, data) => {
if (!err) {
console.info(TAG + "Entering HAS_FLASH success");
if (data != null || data != undefined) {
console.info(TAG + "Entering HAS_FLASH data is not null || undefined");
console.info(TAG + "Entering HAS_FLASH PASSED with HAS_FLASH is: " + data);
expect(data).assertEqual(true);
}
} else {
console.info(TAG + "Entering HAS_FLASH FAILED : " + err.message);
expect().assertFail();
}
console.info(TAG + "Entering HAS_FLASH ends here");
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_OPEN_SUPPORTED
* @tc.name : check if flash mode open is supported-camera0Input api
* @tc.desc : check if flash mode open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_OPEN
* @tc.name : set flash mode open camera0 api
* @tc.desc : set flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_OPEN).assertEqual(1);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_OPEN ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_OPEN
* @tc.name : get flash mode open camera0 api
* @tc.desc : get flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN success");
if (data == 1) {
console.info(TAG + "GET_FLASH_MODE_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_OPEN PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_OPEN FAILED : " + err.message);
console.info(TAG + "GET_FLASH_MODE_OPEN ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_ALWAYS_OPEN SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_ALWAYS_OPEN supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : set flash mode always open camera0 api
* @tc.desc : set flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN).assertEqual(3);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : get flash mode always open camera0 api
* @tc.desc : get flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN success");
if (data == 3) {
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN FAILED : " + err.message);
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_AUTO_SUPPORTED
* @tc.name : check if flash mode auto is supported-camera0Input api
* @tc.desc : check if flash mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_AUTO SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_AUTO supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED FAILED :" + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_AUTO
* @tc.name : set flash mode auto camera0 api
* @tc.desc : set flash mode auto open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering SET_FLASH_MODE_AUTO PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_AUTO).assertEqual(2);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_AUTO
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO success");
if (data == 2) {
console.info(TAG + "GET_FLASH_MODE_AUTO data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_AUTO PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_AUTO FAILED :" + err.message);
console.info(TAG + "GET_FLASH_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_CLOSE_SUPPORTED
* @tc.name : check if flash mode close is supported-camera0Input api
* @tc.desc : check if flash mode close is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_CLOSE_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED to operate");
camera0Input.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_CLOSE, async (err, data) => {
if (!err) {
console.info(TAG + "Entering FLASH_MODE_CLOSE SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_CLOSE supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED PASSED");
}
} else {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED FAILED :" + err.message);
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_CLOSE
* @tc.name : set flash mode close camera0 api
* @tc.desc : set flash mode close open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE to operate");
camera0Input.setFlashMode(cameraObj.FlashMode.FLASH_MODE_CLOSE, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_CLOSE).assertEqual(0);
}
else {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_CLOSE
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE to operate");
camera0Input.getFlashMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE success");
if (data == 0) {
console.info(TAG + "GET_FLASH_MODE_CLOSE data is not null || undefined: ");
expect(true).assertTrue();
console.info(TAG + "Current FlashMode is: " + data);
console.info(TAG + "GET_FLASH_MODE_CLOSE PASSED");
}
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_CLOSE FAILED :" + err.message);
console.info(TAG + "GET_FLASH_MODE_CLOSE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_ZOOM_RATIO
* @tc.name : get zoom ratio camera-0 cameraId api
* @tc.desc : get zoom ratio camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_ZOOM_RATIO', 0, async function (done) {
console.info("--------------GET_ZOOM_RATIO--------------");
camera0Input.getZoomRatioRange(async (err, data) => {
if (!err) {
if (data != null && data != undefined) {
console.info(TAG + "Entering GET_ZOOM_RATIO data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering GET_ZOOM_RATIO Success " + data)
}
} else {
expect().assertFail();
console.info(TAG + "Entering GET_ZOOM_RATIO FAILED: " + err.message);
}
console.info(TAG + "Entering GET_ZOOM_RATIO ends here");
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_1_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_1_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(1, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 1");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(1);
console.info(TAG + "SET_GET_ZOOM_1_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_1_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_1_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_2_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_2_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(2, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 2");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(2);
console.info(TAG + "SET_GET_ZOOM_2_ASYNC PASSED ");
}
else {
expect().assertFail();
console.info(TAG + "GET_ZOOM_2_ASYNC FAILED" + err.message);
}
})
} else {
expect().assertFail();
console.info(TAG + "SET_ZOOM_2_ASYNC FAILED" + err.message);
}
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_3_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_3_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(3, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 3");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(3);
console.info(TAG + "SET_GET_ZOOM_3_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_3_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_3_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_4_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_4_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(4, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 4");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(4);
console.info(TAG + "SET_GET_ZOOM_4_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_4_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_4_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_5_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_5_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(5, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 5");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(5);
console.info(TAG + "SET_GET_ZOOM_5_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_5_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_5_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_6_ASYNC
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_6_ASYNC', 0, async function (done) {
camera0Input.setZoomRatio(6, (err, data) => {
if (!err) {
console.info(TAG + "setZoomRatio success: 6");
console.info(TAG + "getZoomRatio called")
camera0Input.getZoomRatio((err, data1) => {
if (!err) {
console.info(TAG + "getZoomRatio success : " + data1);
expect(data1).assertEqual(6);
console.info(TAG + "SET_GET_ZOOM_6_ASYNC PASSED ");
}
else {
console.info(TAG + "GET_ZOOM_6_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
} else {
console.info(TAG + "SET_ZOOM_6_ASYNC FAILED" + err.message);
expect().assertFail();
}
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_LOCKED_SUPPORTED
* @tc.name : check if focus mode locked is supported-camera0Input api
* @tc.desc : check if focus mode locked is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Focus Mode Locked Supported SUCCESS: " + data);
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Focus Mode Locked Supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_LOCKED_SUPPORTED is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_LOCKED_SUPPORTED FAILED :" + err.message);
expect().assertFail()
console.info(TAG + "IS_FOCUS_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_LOCKED
* @tc.name : set focus mode locked camera0 api
* @tc.desc : set focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Mode Locked SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED FAILED : ")
expect().assertFail();
} else {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_LOCKED
* @tc.name : get focus mode locked camera0 api
* @tc.desc : get focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_LOCKED to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Mode Locked SUCCESS: " + data);
console.info(TAG + "Get Focus Mode Locked data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_FOCUS_MODE_LOCKED PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_LOCKED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_MANUAL_SUPPORTED
* @tc.name : check if focus mode manual is supported-camera0Input api
* @tc.desc : check if focus mode manual is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_MANUAL_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_MANUAL, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_MANUAL_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED FAILED " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_MANUAL
* @tc.name : set focus mode manual camera0 api
* @tc.desc : set focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_MANUAL);
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_MANUAL).assertEqual(0)
}
else {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_MANUAL
* @tc.name : get focus mode manual camera0 api
* @tc.desc : get focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_MANUAL data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_FOCUS_MODE_MANUAL PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_MANUAL FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_MANUAL ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode manual
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT_focus mode manual', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode manual
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT_focus mode manual', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_CONTINUOUS_SUPPORTED
* @tc.name : check if focus mode continuous is supported-camera0Input api
* @tc.desc : check if focus mode continuous is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_CONTINUOUS_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_CONTINOUS_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_CONTINUOUS
* @tc.name : set focus mode continuous camera0 api
* @tc.desc : set focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
expect(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO).assertEqual(1);
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS PASSED");
}
else {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_CONTINUOUS
* @tc.name : get focus mode continuous camera0 api
* @tc.desc : get focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode continuous
* @tc.name : set focus Point locked camera0 api
* @tc.desc : set focus Point locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode continuous
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_AUTO_SUPPORTED
* @tc.name : check if focus mode auto is supported-camera0Input api
* @tc.desc : check if focus mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED to operate");
camera0Input.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED data is not null || undefined");
console.info(TAG + "FOCUS_MODE_AUTO_SUPPORTED is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_AUTO
* @tc.name : set focus mode auto camera0 api
* @tc.desc : set focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO to operate");
camera0Input.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_AUTO);
if (data != null || data != undefined) {
expect(cameraObj.FocusMode.FOCUS_MODE_AUTO).assertEqual(2);
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO PASSED")
}
} else {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_AUTO
* @tc.name : get focus mode auto camera0 api
* @tc.desc : get focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO to operate");
camera0Input.getFocusMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO SUCCESS");
console.info(TAG + "GET_FOCUS_MODE_AUTO data is not null || undefined: ");
console.info(TAG + "Current FocusMode is: " + data);
expect(data).assertEqual(2);
console.info(TAG + "GET_FOCUS_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_AUTO FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT_focus mode auto
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_POINT to operate");
camera0Input.setFocusPoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering SetFocus Point, current FocusMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT_focus mode auto
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
camera0Input.getFocusPoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Focus Point SUCCESS: " + JSON.stringify(data));
console.info(TAG + "Current Focus Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_LOCKED_SUPPORTED
* @tc.name : check if exposure mode locked is supported-camera0Input api
* @tc.desc : check if exposure mode locked is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode Locked supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode Locked supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_Locked_Supported is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_LOCKED
* @tc.name : set exposure mode locked camera0 api
* @tc.desc : set exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode Locked, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED);
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED FAILED")
expect().assertFail();
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_LOCKED
* @tc.name : get exposure mode locked camera0 api
* @tc.desc : get exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_LOCKED to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode locked
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode locked
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASRANGE_exposure mode continuous auto
* @tc.name : get exposure bias range camera0 api
* @tc.desc : get exposure bias range camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASRANGE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASRANGE to operate");
camera0Input.getExposureBiasRange(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias range SUCCESS");
console.info(TAG + "Current Exposure bias range is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_BIASRANGE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASRANGE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASRANGE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode locked
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(-4, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "-4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode locked
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_AUTO_SUPPORTED
* @tc.name : check if exposure mode auto is supported-camera0Input api
* @tc.desc : check if exposure mode auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode Auto supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode Auto supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_Auto_Supported is: " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_AUTO
* @tc.name : set exposure mode auto camera0 api
* @tc.desc : set exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode auto,current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
if (data != null || data != undefined) {
expect(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO).assertEqual(1);
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO PASSED")
}
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_AUTO
* @tc.name : get exposure mode auto camera0 api
* @tc.desc : get exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('GET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_AUTO to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure Mode SUCCESS");
console.info(TAG + "Get Exposure Mode data is not null || undefined: ");
console.info(TAG + "Current ExposureMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode auto
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode auto
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(1, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "1");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode auto
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED
* @tc.name : check if exposure mode continuous auto is supported-camera0Input api
* @tc.desc : check if exposure mode continuous auto is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED to operate");
camera0Input.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Is Exposure Mode continuous Auto supported SUCCESS ");
if (data != null || data != undefined) {
console.info(TAG + "Entering Is Exposure Mode continuous Auto supported data is not null || undefined");
console.info(TAG + "Exposure_Mode_continuous_Auto_Supported is: " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED PASSED: ");
}
} else {
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : set exposure mode continuous auto camera0 api
* @tc.desc : set exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
camera0Input.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Mode continuous auto,current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED")
expect().AssertFail();
} else {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : get exposure mode continuous auto camera0 api
* @tc.desc : get exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
camera0Input.getExposureMode(async (err, data) => {
if (!err) {
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode continuous auto
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
camera0Input.setExposurePoint(Point, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure Point, current ExposureMode is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode continuous auto
* @tc.name : get exposure point camera0 api
* @tc.desc : get exposure point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
camera0Input.getExposurePoint(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure point SUCCESS");
console.info(TAG + "Current Exposure Point is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_POINT ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
camera0Input.setExposureBias(4, async (err, data) => {
if (!err) {
console.info(TAG + "Entering Set Exposure bias is: " + "4");
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
} else {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASVALUE_exposure mode continuous auto
* @tc.name : get exposure bias value camera0 api
* @tc.desc : get exposure bias value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASVALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASVALUE to operate");
camera0Input.getExposureValue(async (err, data) => {
if (!err) {
console.info(TAG + "Entering Get Exposure bias value SUCCESS");
console.info(TAG + "Current Exposure bias value is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_BIASVALUE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASVALUE FAILED : " + err.message);
console.info(TAG + "GET_EXPOSURE_BIASVALUE ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
})
/**
* @tc.number : isMirrorSupported_PHOTO_OUTPUT
* @tc.name : isMirrorSupported
* @tc.desc : isMirrorSupported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('isMirrorSupported_PHOTO_OUTPUT', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT to operate");
photoOutputAsync.isMirrorSupported(async (err, data) => {
if (!err) {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT is success");
console.info(TAG + "isMirrorSupported : " + data);
expect(true).assertTrue();
} else {
expect().assertFail();
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : setMirror_true
* @tc.name : setMirror true
* @tc.desc : setMirror true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_true', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_true to operate");
photoOutputAsync.setMirror(true, async (err, data) => {
if (!err) {
console.info(TAG + "Entering setMirror_true is success:");
console.info(TAG + "setMirror is : " + 'True');
expect(true).assertTrue();
} else {
expect().assertFail();
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : VIDEO_OUTPUT_START
* @tc.name : VideoOutput start async api
* @tc.desc : VideoOutput start async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_START', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + "Entering VIDEO_OUTPUT_START videoOutput == null || undefined")
} else {
console.info(TAG + "Entering VIDEO_OUTPUT_START to operate")
await sleep(1)
videoOutput.start(async (err, data) => {
if (!err) {
console.info(TAG + "Entering VIDEO_OUTPUT_START success: " + JSON.stringify(data))
if (data == undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "Entering VIDEO_OUTPUT_START FAILED: " + err.message)
}
})
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : VIDEO_RECORDER_START
* @tc.name : VideoRecorder start async api
* @tc.desc : VideoRecorder start async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_RECORDER_START', 0, async function (done) {
if (videoRecorder == null || videoRecorder == undefined) {
console.info(TAG + 'Entering VideoRecorder start videoRecorder == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_RECORDER_START to operate')
videoRecorder.start()
console.info(TAG + 'VIDEO_RECORDER_START called');
sleep(3);
console.info(TAG + 'Capture with photosettings1 during video - Start & setMirror: true')
photoOutputAsync.capture(photosettings1)
console.info(TAG + 'Capture during Video - End.')
expect(true).assertTrue()
console.info(TAG + 'Entering VIDEO_RECORDER_START PASSED')
console.info(TAG + 'Entering VIDEO_RECORDER_START ends here')
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : VIDEO_OUTPUT_STOP
* @tc.name : VideoOutput stop async api
* @tc.desc : VideoOutput stop async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_STOP', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + 'Entering VideoOutput stop videoOutput == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP to operate')
videoOutput.stop(async (err, data) => {
if (!err) {
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP success: ' + JSON.stringify(data))
if (data == undefined) {
expect(true).assertTrue()
}
} else {
expect().assertFail()
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP FAILED: ' + err.message)
}
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP ends here')
await sleep(1)
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : VIDEO_RECORDER_STOP
* @tc.name : VideoRecorder stop async api
* @tc.desc : VideoRecorder stop async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_RECORDER_STOP', 0, async function (done) {
if (videoRecorder == null || videoRecorder == undefined) {
console.info(TAG + 'Entering VideoRecorder stop videoRecorder == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_RECORDER_STOP to operate')
videoRecorder.stop()
console.info(TAG + 'VideoRecorder stop stopVideo done.')
console.info(TAG + 'Entering VIDEO_RECORDER_STOP PASSED')
expect(true).assertTrue()
}
await sleep(1)
done()
})
/**
* @tc.number : CAPTURE_SESSION_STOP
* @tc.name : CaptureSession stop async api
* @tc.desc : CaptureSession stop async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_STOP', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering CaptureSession stop captureSession == null || undefined')
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_STOP to operate')
await sleep(1)
captureSession.stop((err, data) => {
if (!err) {
console.info(TAG + 'Entering CaptureSession stop success')
expect(true).assertTrue()
console.info(TAG + 'Entering CAPTURE_SESSION_STOP PASSED')
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_STOP FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering CAPTURE_SESSION_STOP ends here')
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : CAPTURE_SESSION_RELEASE
* @tc.name : CaptureSession release async api
* @tc.desc : CaptureSession release async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_RELEASE', 0, async function (done) {
if (captureSession == null || captureSession == undefined) {
console.info(TAG + 'Entering CaptureSession release captureSession == null || undefined')
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE to operate')
await sleep(1)
captureSession.release(async (err, data) => {
if (!err) {
console.info(TAG + 'Entering CaptureSession release success')
if (data != null || data != undefined) {
console.info(TAG + 'Entering CaptureSession release data is not null || undefined')
expect(true).assertTrue()
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE PASSED')
}
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE FAILED: ' + err.message)
expect().assertFail();
}
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE ends here')
await sleep(1)
done()
})
await sleep(1)
done()
}
})
/**
* @tc.number : VIDEOOUPUT_RELEASE_SUCCESS
* @tc.name : videooutput release api
* @tc.desc : videooutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEOOUPUT_RELEASE_SUCCESS', 0, async function (done) {
if (videoOutput == null || videoOutput == undefined) {
console.info(TAG + "Entering videooutput.release previewOutput == null || undefined");
} else {
console.info(TAG + "Entering VIDEOOUPUT_RELEASE_SUCCESS to operate");
videoOutput.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering videooutput.release success");
if (data != null || data != undefined) {
console.info(TAG + "Entering videooutput.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering VIDEOOUPUT_RELEASE_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering VIDEOOUPUT_RELEASE_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering VIDEOOUPUT_RELEASE_SUCCESS ends here");
await sleep(1);
done();
}
})
await sleep(1);
done();
}
})
/**
* @tc.number : PREVIEWOUPUT_RELEASE_SUCCESS
* @tc.name : previewOutput release api
* @tc.desc : previewOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEWOUPUT_RELEASE_SUCCESS', 0, async function (done) {
if (previewOutput == null || previewOutput == undefined) {
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE_SUCCESS previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE_SUCCESS to operate");
previewOutput.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering previewOutput.release success");
if (data != null || data != undefined) {
console.info(TAG + "Entering previewOutput.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering previewOutput.release PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering PREVIEWOUPUT_RELEASE_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering previewOutput.release ends here");
await sleep(1);
done();
}
})
await sleep(1);
done();
}
})
/**
* @tc.number : PHOTOOUPUT_RELEASE
* @tc.name : photoOutput release api
* @tc.desc : photoOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTOOUPUT_RELEASE', 0, async function (done) {
if (photoOutputAsync == null || photoOutputAsync == undefined) {
console.info(TAG + "Entering PHOTOOUPUT_RELEASE photoOutputAsync == null || undefined");
} else {
console.info(TAG + "Entering PHOTOOUPUT_RELEASE to operate");
photoOutputAsync.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering photoOutputAsync.release success");
expect(true).assertTrue();
console.info(TAG + "Entering PHOTOOUPUT_RELEASE PASSED");
} else {
expect().assertFail();
console.info(TAG + "Entering PHOTOOUPUT_RELEASE FAILED: " + err.message);
console.info(TAG + "Entering photoOutputAsync.release ends here");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CAMERAINPUT_RELEASE_SUCCESS
* @tc.name : camera Input release api
* @tc.desc : camera Input release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERAINPUT_RELEASE_SUCCESS', 0, async function (done) {
if (camera0Input == null || camera0Input == undefined) {
console.info(TAG + "Entering camera0Input.release camera0Input == null || undefined");
} else {
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS to operate");
camera0Input.release(async (err, data) => {
if (!err) {
console.info(TAG + "Entering camera0Input.release success");
if (data != null || data != undefined) {
console.info(TAG + "Entering camera0Input.release data is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS PASSED");
}
} else {
expect().assertFail();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS FAILED: " + err.message);
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS ends here");
await sleep(1);
done();
}
})
await sleep(1);
done();
}
})
})
}
\ No newline at end of file
multimedia/camera/camera_js_standard/src/main/ets/MainAbility/test/CameraJSUnitVideoPromise.test.ets 已删除 100644 → 0
浏览文件 @ 119f5fb2
/*
* Copyright (C) 2022 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 cameraObj from '@ohos.multimedia.camera'
import media from '@ohos.multimedia.media'
import image from '@ohos.multimedia.image';
import mediaLibrary from '@ohos.multimedia.mediaLibrary'
import fileio from '@ohos.fileio';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
import bundle from '@ohos.bundle'
// @ts-nocheck
import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index';
let TAG = 'CameraModuleTest: '
var cameraManagerPromise
var camerasArrayPromise
var camera0InputPromise
var previewOutputPromise
var videoRecorder
var photoOutputPromise
let fdPath;
let fileAsset;
let fdNumber;
var minFrameRate_Grp0=12;
var maxFrameRate_Grp0=12;
var minFrameRate_Mix=14;
var maxFrameRate_Mix=15;
var minFrameRate_Err1=11;
var maxFrameRate_Err1=31;
var minFrameRate_Err2=14;
var maxFrameRate_Err2=28;
var minFrameRate_Err3=16;
var maxFrameRate_Err3=25;
var minFrameRate_Grp20=30;
var maxFrameRate_Grp20=30;
var Point1 = { x: 1, y: 1 }
var Point2 = { x: 2, y: 2 }
var Point3 = { x: 3, y: 3 }
var photosettings1 = {
rotation: 0,
quality: 0,
location: {
latitude: 12.9705,
longitude: 77.7329,
altitude: 920.0000,
},
}
var photosettings2 = {
rotation: 90,
quality: 1,
location: {
latitude: 20,
longitude: 78,
altitude: 8586,
},
}
var photosettings3 = {
quality: 2,
location: {
latitude: 0,
longitude: 0,
altitude: 0,
},
}
var photosettings4 = {
rotation: 180,
location: {
latitude: -1,
longitude: -1,
altitude: -1,
},
}
var photosettings5 = {
rotation: 270,
}
let configFile = {
audioBitrate: 48000,
audioChannels: 2,
audioCodec: 'audio/mp4a-latm',
audioSampleRate: 48000,
durationTime: 1000,
fileFormat: 'mp4',
videoBitrate: 48000,
videoCodec: 'video/mp4v-es',
videoFrameWidth: 640,
videoFrameHeight: 480,
videoFrameRate: 30
}
let videoConfig = {
audioSourceType: 1,
videoSourceType: 0,
profile: configFile,
url: 'file:///data/media/01.mp4',
orientationHint: 0,
location: { latitude: 30, longitude: 130 },
maxSize: 100,
maxDuration: 500
}
var surfaceId1
var videoId
var videoOutputPromise
var captureSessionPromise
export default function cameraJSUnitVideoPromise(surfaceId: any) {
async function getImageReceiverSurfaceId() {
console.log(TAG + 'Entering create Image receiver')
var receiver = image.createImageReceiver(640, 480, 4, 8)
console.log(TAG + 'before receiver check')
if (receiver !== undefined) {
console.log(TAG + 'Receiver is ok')
surfaceId1 = await receiver.getReceivingSurfaceId()
console.log(TAG + 'Received id: ' + JSON.stringify(surfaceId1))
} else {
console.log(TAG + 'Receiver is not ok')
}
}
function sleep(time) {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(1)
}, time * 1000)
}).then(() => {
console.info(`sleep ${time} over...`)
})
}
async function applyPermission() {
let appInfo = await bundle.getApplicationInfo('com.open.harmony.multimedia.cameratest', 0, 100);
let atManager = abilityAccessCtrl.createAtManager();
if (atManager != null) {
let tokenID = appInfo.accessTokenId;
console.info('[permission] case accessTokenID is ' + tokenID);
let permissionName1 = 'ohos.permission.CAMERA';
let permissionName2 = 'ohos.permission.MICROPHONE';
let permissionName3 = 'ohos.permission.MEDIA_LOCATION';
let permissionName4 = 'ohos.permission.READ_MEDIA';
let permissionName5 = 'ohos.permission.WRITE_MEDIA';
await atManager.grantUserGrantedPermission(tokenID, permissionName1, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName2, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName3, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName4, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
await atManager.grantUserGrantedPermission(tokenID, permissionName5, 1).then((result) => {
console.info('[permission] case grantUserGrantedPermission success :' + result);
}).catch((err) => {
console.info('[permission] case grantUserGrantedPermission failed :' + err);
});
} else {
console.info('[permission] case apply permission failed, createAtManager failed');
}
}
async function getFd(pathName) {
let displayName = pathName;
const mediaTest = mediaLibrary.getMediaLibrary();
let fileKeyObj = mediaLibrary.FileKey;
let mediaType = mediaLibrary.MediaType.VIDEO;
let publicPath = await mediaTest.getPublicDirectory(mediaLibrary.DirectoryType.DIR_VIDEO);
let dataUri = await mediaTest.createAsset(mediaType, displayName, publicPath);
if (dataUri != undefined) {
let args = dataUri.id.toString();
let fetchOp = {
selections: fileKeyObj.ID + "=?",
selectionArgs: [args],
}
let fetchFileResult = await mediaTest.getFileAssets(fetchOp);
fileAsset = await fetchFileResult.getAllObject();
fdNumber = await fileAsset[0].open('Rw');
fdPath = "fd://" + fdNumber.toString();
}
}
async function closeFd() {
if (fileAsset != null) {
await fileAsset[0].close(fdNumber).then(() => {
console.info('[mediaLibrary] case close fd success');
}).catch((err) => {
console.info('[mediaLibrary] case close fd failed');
});
} else {
console.info('[mediaLibrary] case fileAsset is null');
}
}
async function getvideosurface() {
await getFd('01.mp4');
videoConfig.url = fdPath;
media.createVideoRecorder((err, recorder) => {
console.info(TAG + 'createVideoRecorder called')
videoRecorder = recorder
console.info(TAG + 'videoRecorder is :' + JSON.stringify(videoRecorder))
console.info(TAG + 'videoRecorder.prepare called.')
videoRecorder.prepare(videoConfig, (err) => {
console.info(TAG + 'videoRecorder.prepare success.')
})
videoRecorder.getInputSurface((err, id) => {
console.info(TAG + 'getInputSurface called')
videoId = id
console.info(TAG + 'getInputSurface surfaceId: ' + JSON.stringify(videoId))
})
})
}
describe('VideoModePromise', function () {
console.info(TAG + '----------Camera-VideoMode-Promise--------------')
beforeAll(async function () {
await applyPermission();
console.info('beforeAll case');
})
beforeEach(function () {
sleep(5);
console.info('beforeEach case');
})
afterEach(async function () {
await closeFd();
console.info('afterEach case');
})
afterAll(function () {
console.info('afterAll case');
})
/**
* @tc.number : GET_CAMERA_MANAGER_PROMISE
* @tc.name : Create camera manager instance promise api
* @tc.desc : Create camera manager instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERA_MANAGER_PROMISE', 0, async function (done) {
console.info('--------------GET_CAMERA_MANAGER_PROMISE--------------')
cameraManagerPromise = await cameraObj.getCameraManager(null)
console.info(TAG + 'Entering Get cameraManagerPromise cameraManagerPromise: ' + cameraManagerPromise)
if (cameraManagerPromise != null && cameraManagerPromise != undefined) {
expect(true).assertTrue()
console.info(TAG + 'Entering GET_CAMERA_MANAGER_PROMISE PASSED')
} else {
expect().assertFail()
console.info(TAG + 'Entering GET_CAMERA_MANAGER_PROMISE FAILED')
}
console.info(TAG + 'Entering GET_CAMERA_MANAGER_PROMISE ends here')
await sleep(1)
done()
})
/**
* @tc.number : CAMERA_STATUS_CALLBACK
* @tc.name : camera status callback on CameraManager async api
* @tc.desc : camera status callback on CameraManager async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_STATUS_CALLBACK', 0, async function (done) {
if (cameraManagerPromise == null || cameraManagerPromise == undefined) {
console.info(TAG + 'Entering Camera status Callback cameraManagerPromise == null || undefined')
} else {
console.info(TAG + 'Entering CAMERA_STATUS_CALLBACK to operate')
await sleep(1)
cameraManagerPromise.on('cameraStatus', async (err, data) => {
if (!err) {
console.info(TAG + "Camera status Callback on cameraManagerPromise is success");
if (data != null || data != undefined) {
console.info(TAG + "CAMERA_STATUS_CALLBACK CameraStatusInfo_Camera: " + data.camera);
console.info(TAG + "CAMERA_STATUS_CALLBACK CameraStatusInfo_Status: " + data.status);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_STATUS_CALLBACK FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : GET_CAMERAS_PROMISE
* @tc.name : Create camera manager instance promise api
* @tc.desc : Create camera manager instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_CAMERAS_PROMISE', 0, async function (done) {
console.info('--------------GET_CAMERAS_PROMISE--------------')
camerasArrayPromise = await cameraManagerPromise.getCameras()
console.info(TAG + 'Entering Get Cameras Promise: ' + JSON.stringify(camerasArrayPromise))
if (camerasArrayPromise != null && camerasArrayPromise.length > 0) {
console.info(TAG + 'Entering Get Cameras Promise success')
for (var i = 0; i < camerasArrayPromise.length; i++) {
// Get the variables from camera object
var cameraId = camerasArrayPromise[i].cameraId
console.info(TAG + 'Entering Get Cameras Promise camera' + i + 'Id: ' + cameraId)
var cameraPosition = camerasArrayPromise[i].cameraPosition
console.info(TAG + 'Entering Get Cameras Promise camera' + i + 'Position: ' + cameraPosition)
var cameraType = camerasArrayPromise[i].cameraType
console.info(TAG + 'Entering Get Cameras Promise camera' + i + 'Type: ' + cameraType)
var connectionType = camerasArrayPromise[i].connectionType
console.info(TAG + 'Entering Get Cameras Promise connection' + i + 'Type: ' + connectionType)
}
expect(true).assertTrue()
console.info(TAG + 'Entering GET_CAMERAS_PROMISE PASSED')
} else {
expect().assertFail()
console.info(TAG + 'Entering GET_CAMERAS_PROMISE FAILED')
}
console.info(TAG + 'Entering GET_CAMERAS_PROMISE ends here')
await sleep(1)
done()
})
/*CAMERA-0 Scripts*/
/**
* @tc.number : CREATE_CAMERA_INPUT_PROMISE
* @tc.name : Create camerainput from camera-0 cameraId promise api
* @tc.desc : Create camerainput from camera-0 cameraId promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAMERA_INPUT_PROMISE', 0, async function (done) {
console.info('--------------CREATE_CAMERA_INPUT_PROMISE--------------')
camera0InputPromise = await cameraManagerPromise.createCameraInput(camerasArrayPromise[0].cameraId)
console.info(TAG + 'Entering Create camera input promise camera0InputPromise: ' + JSON.stringify(camera0InputPromise))
if (camera0InputPromise != null && camera0InputPromise != undefined) {
console.info(TAG + 'Entering Create camera input promise camera0InputPromise is not null || undefined')
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_CAMERA_INPUT_PROMISE PASSED')
} else {
expect().assertFail()
console.info(TAG + 'Entering CREATE_CAMERA_INPUT_PROMISE FAILED')
}
console.info(TAG + 'Entering CREATE_CAMERA_INPUT_PROMISE ends here')
await sleep(1)
done()
})
/**
* @tc.number : CAMERA_INPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERA_INPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering Camera input error callback camera0InputPromise == null || undefined");
} else {
console.info(TAG + "Entering CAMERA_INPUT_CALLBACK_ON_ERROR to operate");
camera0InputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "camera0InputPromise error callback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAMERA_INPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CREATE_PREVIEW_OUTPUT_PROMISE
* @tc.name : Create previewoutput promise api
* @tc.desc : Create previewoutput promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PREVIEW_OUTPUT_PROMISE', 0, async function (done) {
console.info('--------------CREATE_PREVIEW_OUTPUT_PROMISE--------------')
previewOutputPromise = await cameraObj.createPreviewOutput(surfaceId)
console.info(TAG + 'Entering Create previewOutputPromise: ' + JSON.stringify(previewOutputPromise))
if (previewOutputPromise != null && previewOutputPromise != undefined) {
console.info(TAG + 'Entering Create previewOutputPromise is not null || undefined')
expect(true).assertTrue();
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT_PROMISE PASSED')
} else {
expect().assertFail();
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT_PROMISE FAILED')
}
console.info(TAG + 'Entering CREATE_PREVIEW_OUTPUT_PROMISE ends here')
await sleep(1)
done()
})
/**
* @tc.number : FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : FocusStateChange callback api
* @tc.desc : FocusStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering FocusStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0InputPromise.on('focusStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "FocusState callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current FocusState is : " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "FOCUSSTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT
* @tc.name : ExposureStateChange callback api
* @tc.desc : ExposureStateChange callback api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering ExposureStateChange callback previewOutput == null || undefined");
} else {
console.info(TAG + "Entering EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT to operate");
camera0InputPromise.on('exposureStateChange', async (err, data) => {
if (!err) {
console.info(TAG + "ExposureStateChange callback is success");
if (data != null || data != undefined) {
console.info(TAG + "Current ExposureStateChange is: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "EXPOSURESTATECHANGE_CALLBACK_ON_CAMERAINPUT FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : PreviewOutput callback onerror async api
* @tc.desc : PreviewOutput callback onerror async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + 'Entering PreviewOutputError callback previewOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering PREVIEW_OUTPUT_CALLBACK_ON_ERROR to operate')
await sleep(1)
previewOutputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PreviewOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CREATE_VIDEO_OUTPUT_PROMISE
* @tc.name : Create videooutput promise api
* @tc.desc : Create videooutput promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_VIDEO_OUTPUT_PROMISE', 0, async function (done) {
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT_PROMISE to operate')
await getvideosurface()
await sleep(2)
videoOutputPromise = await cameraObj.createVideoOutput(videoId)
console.info(TAG + 'Entering Create videoOutputPromise: ' + videoOutputPromise)
if (videoOutputPromise != null && videoOutputPromise != undefined) {
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT_PROMISE PASSED')
} else {
expect().assertFail();
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT_PROMISE FAILED')
}
console.info(TAG + 'Entering CREATE_VIDEO_OUTPUT_PROMISE ends here');
await sleep(1);
done();
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : VideoOutput callback onerror async api
* @tc.desc : VideoOutput callback onerror async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_ERROR videoOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_ERROR to operate')
await sleep(1)
videoOutputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + 'VideoOutput Errorcallback is success')
if (data != null || data != undefined) {
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue()
}
} else {
expect().assertFail()
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1)
done()
})
await sleep(1)
done();
}
})
/*PhotoOutput APIs test script*/
/**
* @tc.number : CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE
* @tc.name : Create PhotoOutput instance promise api
* @tc.desc : Create PhotoOutput instance promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE', 0, async function (done) {
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE to operate");
console.info(TAG + 'Entering getImageReceiverSurfaceId')
await getImageReceiverSurfaceId()
await sleep(1)
photoOutputPromise = await cameraObj.createPhotoOutput(surfaceId1);
console.info(TAG + "Entering createPhotoOutput success");
if (photoOutputPromise != null || photoOutputPromise != undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering CREATE_PHOTO_OUTPUT_SUCCESS_PROMISE FAILED : ");
console.info(TAG + "Entering createPhotoOutput ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : PHOTO_OUTPUT_CALLBACK_ON_ERROR
* @tc.name : Photo output callback on error api
* @tc.desc : Photo output callback on error api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_OUTPUT_CALLBACK_ON_ERROR', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo output callback on error photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_OUTPUT_CALLBACK_ON_ERROR to operate");
photoOutputPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + "PhotoOutputError callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_OUTPUT_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CREATE_CAPTURE_SESSION_PROMISE
* @tc.name : Create capturesession promise api
* @tc.desc : Create capturesession promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CREATE_CAPTURE_SESSION_PROMISE', 0, async function (done) {
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION_PROMISE to operate')
captureSessionPromise = await cameraObj.createCaptureSession(null)
console.info(TAG + 'Entering Create captureSessionPromise: ' + captureSessionPromise)
if (captureSessionPromise != null && captureSessionPromise != undefined) {
expect(true).assertTrue()
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION_PROMISE PASSED')
} else {
expect().assertFail()
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION_PROMISE FAILED')
}
console.info(TAG + 'Entering CREATE_CAPTURE_SESSION_PROMISE ends here');
await sleep(1);
done();
})
/**
* @tc.number : CAP_SES_CALLBACK_ON_ERROR
* @tc.name : CaptureSession callback onerror async api
* @tc.desc : CaptureSession callback onerror async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAP_SES_CALLBACK_ON_ERROR', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + 'Entering captureSession errorcallback captureSessionPromise == null || undefined')
} else {
console.info(TAG + 'Entering CAP_SES_CALLBACK_ON_ERROR to operate')
await sleep(1)
captureSessionPromise.on('error', async (err, data) => {
if (!err) {
console.info(TAG + " captureSession errorcallback is success");
if (data != null || data != undefined) {
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR with ErrorCode: " + data.code);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "CAP_SES_CALLBACK_ON_ERROR FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/*CaptureSession APIs*/
/**
* @tc.number : BEGIN_CONFIG_SUCCESS_PROMISE
* @tc.name : CaptureSession_Begin config promise api
* @tc.desc : CaptureSession_Begin config promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('BEGIN_CONFIG_SUCCESS_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Create captureSession == null || undefined");
} else {
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS_PROMISE to operate");
const promise = await captureSessionPromise.beginConfig();
console.info(TAG + "Entering beginConfig success:");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS_PROMISE beginConfig PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS_PROMISE FAILED : ");
}
console.info(TAG + "Entering BEGIN_CONFIG_SUCCESS_PROMISE ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_INPUT_SUCCESS_PROMISE
* @tc.name : Add Input with camera0Input api
* @tc.desc : Add Input with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_SUCCESS_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Add Input captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE to operate");
const Promise = await captureSessionPromise.addInput(camera0InputPromise);
console.info(TAG + "Entering Add Input success");
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE FAILED: ");
}
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Add preview output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE to operate");
const promise = await captureSessionPromise.addOutput(previewOutputPromise);
console.info(TAG + "Entering Add preview output : Success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE FAILED : ");
}
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_VIDEO_SUCCESS
* @tc.name : Add output with video output api
* @tc.desc : Add output with video output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_VIDEO_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Add video output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS to operate");
const promise = await captureSessionPromise.addOutput(videoOutputPromise);
console.info(TAG + "Entering Add video output success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS FAILED: ");
}
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_PHOTO
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Add output with photo output captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO to operate");
const promise = await captureSessionPromise.addOutput(photoOutputPromise);
console.info(TAG + "Entering Add output with photo output success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO FAILED ");
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : REMOVE_INPUT_SUCCESS
* @tc.name : remove input api
* @tc.desc : remove input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_INPUT_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
const Promise = await captureSessionPromise.removeInput(camera0InputPromise);
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : REMOVE_PREVIEW_OUTPUT_SUCCESS
* @tc.name : Remove preview Output api
* @tc.desc : Remove preview Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PREVIEW_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS to operate");
const Promise = await captureSessionPromise.removeOutput(previewOutputPromise);
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_PREVIEW_OUTPUT_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : REMOVE_PHOTO_OUTPUT_SUCCESS
* @tc.name : Remove photo Output api
* @tc.desc : Remove photo Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_PHOTO_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS to operate");
const Promise = await captureSessionPromise.removeOutput(photoOutputPromise);
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS addInput success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_INPUT_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : REMOVE_VIDEO_OUTPUT_SUCCESS
* @tc.name : Remove video Output api
* @tc.desc : Remove video Output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('REMOVE_VIDEO_OUTPUT_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS to operate");
const Promise = await captureSessionPromise.removeOutput(videoOutputPromise);
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS success " + Promise);
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS FAILED: ");
}
console.info(TAG + "Entering REMOVE_VIDEO_OUTPUT_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_INPUT_SUCCESS_PROMISE
* @tc.name : Add Input with camera0Input api
* @tc.desc : Add Input with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_INPUT_SUCCESS_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE to operate");
const Promise = await captureSessionPromise.addInput(camera0InputPromise);
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE addInput success");
if (Promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE addInput PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE FAILED: ");
}
console.info(TAG + "Entering ADD_INPUT_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE
* @tc.name : Add output with camera0Input api
* @tc.desc : Add output with camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE to operate");
const promise = await captureSessionPromise.addOutput(previewOutputPromise);
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE : Success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE FAILED");
}
console.info(TAG + "Entering ADD_OUTPUT_PREVIEW_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_PHOTO_SUCCESS
* @tc.name : Add output with photo output api
* @tc.desc : Add output with photo output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_PHOTO_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS to operate");
const promise = await captureSessionPromise.addOutput(photoOutputPromise);
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS FAILED ");
}
console.info(TAG + "Entering ADD_OUTPUT_PHOTO_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : ADD_OUTPUT_VIDEO_SUCCESS
* @tc.name : Add output with video output api
* @tc.desc : Add output with video output api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('ADD_OUTPUT_VIDEO_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS captureSession == null || undefined");
} else {
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS to operate");
const promise = await captureSessionPromise.addOutput(videoOutputPromise);
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS PASSED");
}
else {
expect().assertFail();
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS FAILED: ");
}
console.info(TAG + "Entering ADD_OUTPUT_VIDEO_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : GET_FRAME_RATE_RANGE
* @tc.name : get frame rate range camera0 api
* @tc.desc : get frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FRAME_RATE_RANGE', 0, async function (done) {
console.info(TAG + "Entering GET_FRAME_RATE_RANGE to operate");
await videoOutputPromise.getFrameRateRange()
.then(function (data) {
console.info(TAG + "Entering get frame rate range SUCCESS ");
console.info(TAG + "Entering GET_FRAME_RATE_RANGE PASSED : " + JSON.stringify(data))
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering GET_FRAME_RATE_RANGE FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering GET_FRAME_RATE_RANGE ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Grp0
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Grp0', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp0 to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Grp0,maxFrameRate_Grp0)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange SUCCESS");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp0 PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp0 FAILED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp0 ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_MIX
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_MIX', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_MIX to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Mix,maxFrameRate_Mix)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_MIX FAILED");
})
.catch((err) => {
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_MIX PASSED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_MIX ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err1
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err1', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err1 to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Err1,maxFrameRate_Err1)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err1 FAILED");
})
.catch((err) => {
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err1 PASSED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_Err1 ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err2
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err2', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err2 to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Err2,maxFrameRate_Err2)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange SUCCESS");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err2 FAILED");
})
.catch((err) => {
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err2 PASSED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_Err2 ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Err3
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Err3', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Err3 to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Err3,maxFrameRate_Err3)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange SUCCESS");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err3 FAILED");
})
.catch((err) => {
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_Err3 PASSED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_Err3 ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FRAME_RATE_RANGE_Grp20
* @tc.name : set frame rate range camera0 api
* @tc.desc : set frame rate range promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FRAME_RATE_RANGE_Grp20', 0, async function (done) {
console.info(TAG + "Entering SET_FRAME_RATE_RANGE_Grp20 to operate");
await videoOutputPromise.setFrameRateRange(minFrameRate_Grp20,maxFrameRate_Grp20)
.then(function (data) {
console.info(TAG + "Entering setFrameRateRange SUCCESS");
console.info(TAG + "Current FrameRateRange is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp20 PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp20 FAILED: " + err.message);
});
console.info(TAG + "SET_FRAME_RATE_RANGE_Grp20 ends here");
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTEDOFF
* @tc.name : isVideoStabilizationModeSupportedOff
* @tc.desc : isVideoStabilizationModeSupported promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTEDOFF', 0, async function (done) {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF to operate");
await captureSessionPromise.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.OFF)
.then(function (data){
console.info(TAG + "Entering is Video Stabilization Mode OFF Supported SUCCESS ");
console.info(TAG + "isVideoStabilizationModeSupported : " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF PASSED");
})
.catch((err) => {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTEDOFF ends here");
});
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEOFF
* @tc.name : SetVideoStabilizationModeOff
* @tc.desc : SetVideoStabilizationModeOff promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEOFF', 0, async function (done) {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEOFF to operate");
await captureSessionPromise.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.OFF)
.then(function (){
console.info(TAG + "Entering Set VideoStabilization Mode Off SUCCESS, current VideoStabilization Mode is: " + cameraObj.VideoStabilizationMode.OFF);
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEOFF PASSED")
expect(cameraObj.VideoStabilizationMode.OFF).assertEqual(0)
})
.catch((err) => {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEOFF FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEOFF ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATIONMODEOFF
* @tc.name : getVideoStabilizationModeOff
* @tc.desc : getVideoStabilizationModeOff promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATIONMODEOFF', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATIONMODEOFF to operate");
await captureSessionPromise.getActiveVideoStabilizationMode()
.then(function (data){
console.info(TAG + "Entering getVideoStabilizationModeOff SUCCESS");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(data).assertEqual(0);
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEOFF PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEOFF FAILED : " + err.message);
});
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEOFF ends here");
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_LOW
* @tc.name : isVideoStabilizationModeSupported low
* @tc.desc : isVideoStabilizationModeSupported low promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_LOW', 0, async function (done) {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW to operate");
await captureSessionPromise.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.LOW)
.then(function (data){
console.info(TAG + "Entering is Video Stabilization Mode LOW Supported SUCCESS ");
console.info(TAG + "isVideoStabilizationModeSupported : " + data);
expect(data).assertEqual(true);
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW PASSED");
})
.catch((err) => {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_LOW ends here");
});
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODELOW
* @tc.name : SetVideoStabilizationModelow
* @tc.desc : SetVideoStabilizationModelow promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODELOW', 0, async function (done) {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODELOW to operate");
await captureSessionPromise.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.LOW)
.then(function (){
console.info(TAG + "Entering Set VideoStabilization Mode Off SUCCESS, current VideoStabilization Mode is: " + cameraObj.VideoStabilizationMode.LOW);
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODELOW PASSED")
expect(cameraObj.VideoStabilizationMode.LOW).assertEqual(1)
})
.catch((err) => {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODELOW FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODELOW ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATIONMODELOW
* @tc.name : getVideoStabilizationModeLow
* @tc.desc : getVideoStabilizationModeLow promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('GET_VIDEOSTABILIZATIONMODELOW', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATIONMODELOW to operate");
await captureSessionPromise.getActiveVideoStabilizationMode()
.then(function (data){
console.info(TAG + "Entering getVideoStabilizationModeLow SUCCESS");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_VIDEOSTABILIZATIONMODELOW PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODELOW FAILED : " + err.message);
});
console.info(TAG + "GET_VIDEOSTABILIZATIONMODELOW ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE
* @tc.name : isVideoStabilizationModeSupported MIDDLE
* @tc.desc : isVideoStabilizationModeSupported MIDDLE promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE', 0, async function (done) {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE to operate");
await captureSessionPromise.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.MIDDLE)
.then(function (data){
console.info(TAG + "Entering is Video Stabilization Mode MIDDLE Supported SUCCESS ");
console.info(TAG + "isVideoStabilizationModeSupported : " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE PASSED");
})
.catch((err) => {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_MIDDLE ends here");
});
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEMIDDLE
* @tc.name : SetVideoStabilizationModeMIDDLE
* @tc.desc : SetVideoStabilizationModeMIDDLE promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEMIDDLE', 0, async function (done) {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEMIDDLE to operate");
await captureSessionPromise.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.MIDDLE)
.then(function (){
console.info(TAG + "Entering Set VideoStabilization Mode MIDDLE SUCCESS, current VideoStabilization Mode is: " + cameraObj.VideoStabilizationMode.MIDDLE);
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEMIDDLE FAILED")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEMIDDLE PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEMIDDLE ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATIONMODEMIDDLE
* @tc.name : getVideoStabilizationModeMIDDLE
* @tc.desc : getVideoStabilizationModeMIDDLE promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATIONMODEMIDDLE', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATIONMODEMIDDLE to operate");
await captureSessionPromise.getActiveVideoStabilizationMode()
.then(function (data){
console.info(TAG + "Entering getVideoStabilizationModeMIDDLE SUCCESS");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEMIDDLE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEMIDDLE FAILED : " + err.message);
});
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEMIDDLE ends here");
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH
* @tc.name : isVideoStabilizationModeSupported High
* @tc.desc : isVideoStabilizationModeSupported High promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH', 0, async function (done) {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH to operate");
await captureSessionPromise.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.HIGH)
.then(function (data){
console.info(TAG + "Entering is Video Stabilization Mode HIGH Supported SUCCESS ");
console.info(TAG + "isVideoStabilizationModeSupported : " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH PASSED");
})
.catch((err) => {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_HIGH ends here");
});
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEHIGH
* @tc.name : SetVideoStabilizationModeHigh
* @tc.desc : SetVideoStabilizationModeHigh promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEHIGH', 0, async function (done) {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEHIGH to operate");
await captureSessionPromise.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.HIGH)
.then(function (){
console.info(TAG + "Entering Set VideoStabilization Mode High SUCCESS, current VideoStabilization Mode is: " + cameraObj.VideoStabilizationMode.HIGH);
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEHIGH FAILED")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEHIGH PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEHIGH ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATIONMODEHIGH
* @tc.name : getVideoStabilizationModeHigh
* @tc.desc : getVideoStabilizationModeHigh promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATIONMODEHIGH', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATIONMODEHIGH to operate");
await captureSessionPromise.getActiveVideoStabilizationMode()
.then(function (data){
console.info(TAG + "Entering getVideoStabilizationModeHigh SUCCESS");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEHIGH PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEHIGH FAILED : " + err.message);
});
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEHIGH ends here");
await sleep(1);
done();
})
/**
* @tc.number : ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO
* @tc.name : isVideoStabilizationModeSupported Auto
* @tc.desc : isVideoStabilizationModeSupported Auto promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO', 0, async function (done) {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO to operate");
await captureSessionPromise.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.AUTO)
.then(function (data){
console.info(TAG + "Entering is Video Stabilization Mode AUTO Supported SUCCESS ");
console.info(TAG + "isVideoStabilizationModeSupported : " + data);
expect(data).assertEqual(false);
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO PASSED");
})
.catch((err) => {
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO FAILED : " + err.message);
expect().assertFail();
console.info(TAG + "Entering ISVIDEOSTABILIZATIONMODESUPPORTED_AUTO ends here");
});
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_VIDEOSTABILIZATIONMODEAUTO
* @tc.name : SetVideoStabilizationModeAuto
* @tc.desc : SetVideoStabilizationModeAuto promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* VideoStabilizationMode Interface will be change
it('SET_VIDEOSTABILIZATIONMODEAUTO', 0, async function (done) {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEAUTO to operate");
await captureSessionPromise.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.AUTO)
.then(function (){
console.info(TAG + "Entering Set VideoStabilization Mode Auto SUCCESS, current VideoStabilization Mode is: " + cameraObj.VideoStabilizationMode.AUTO);
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEAUTO FAILED")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEAUTO PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_VIDEOSTABILIZATIONMODEAUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_VIDEOSTABILIZATIONMODEAUTO
* @tc.name : getVideoStabilizationModeAuto
* @tc.desc : getVideoStabilizationModeAuto promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_VIDEOSTABILIZATIONMODEAUTO', 0, async function (done) {
console.info(TAG + "Entering GET_VIDEOSTABILIZATIONMODEAUTO to operate");
await captureSessionPromise.getActiveVideoStabilizationMode()
.then(function (data){
console.info(TAG + "Entering getVideoStabilizationModeAuto SUCCESS");
console.info(TAG + "Current VideoStabilizationMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEAUTO PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEAUTO FAILED : " + err.message);
});
console.info(TAG + "GET_VIDEOSTABILIZATIONMODEAUTO ends here");
await sleep(1);
done();
})
/**
* @tc.number : COMMIT_CONFIG_SUCCESS
* @tc.name : commit config api
* @tc.desc : commit config api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('COMMIT_CONFIG_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering Commit config captureSession == null || undefined");
} else {
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS to operate");
const promise = await captureSessionPromise.commitConfig();
console.info(TAG + "Entering commitConfig success");
if (promise == undefined) {
expect(true).assertTrue();
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig PASSED");
}
else {
expect().assertFail()
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig FAILED : ");
console.info(TAG + "Entering COMMIT_CONFIG_SUCCESS commitConfig ends here");
}
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : Preview output callback on frame start api
* @tc.desc : Preview output callback on frame start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering Preview Output callback on frame start previewOutput == null || undefined");
} else {
console.info(TAG + "Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START to operate");
previewOutputPromise.on('frameStart', async (err, data) => {
if (!err) {
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail()
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_START FAILED : + err.message");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : PreviewOutput callback onframeend async api
* @tc.desc : PreviewOutput callback onframeend async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + 'Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END previewOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END to operate')
await sleep(1)
previewOutputPromise.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + "PreviewStop frameEnd Callback is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PREVIEW_OUTPUT_CALLBACK_ON_FRAME_END FAILED : + err.message");
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_FRAME_START
* @tc.name : VideoOutput callback onframestart async api
* @tc.desc : VideoOutput callback onframestart async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_FRAME_START', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + 'Entering Video frameStart Callback videoOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_FRAME_START to operate')
await sleep(1)
videoOutputPromise.on('frameStart', async (err, data) => {
if (!err) {
console.info(TAG + "Video frameStart Callback is success");
if (data != null || data != undefined) {
expect(true).assertTrue();
}
} else {
expect().assertFail()
console.info(TAG + "VIDEO_OUTPUT_CALLBACK_ON_FRAME_START is FAILED : " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : VIDEO_OUTPUT_CALLBACK_ON_FRAME_END
* @tc.name : VideoOutput callback onframeend async api
* @tc.desc : VideoOutput callback onframeend async api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_CALLBACK_ON_FRAME_END', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + 'Entering Video frameEnd callback videoOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_CALLBACK_ON_FRAME_END to operate')
await sleep(1)
videoOutputPromise.on('frameEnd', async (err, data) => {
if (!err) {
console.info(TAG + 'VIDEO_OUTPUT_CALLBACK_ON_FRAME_END is success')
if (data != null || data != undefined) {
expect(true).assertTrue()
}
} else {
expect().assertFail()
console.info(TAG + 'VIDEO_OUTPUT_CALLBACK_ON_FRAME_END FAILED' + err.message)
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
//Capture callback
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_START
* @tc.name : Photo capture callback on capture start api
* @tc.desc : Photo capture callback on capture start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_START', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on capture start photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_START to operate");
photoOutputPromise.on('captureStart', async (err, data) => {
if (!err) {
console.info(TAG + "CaptureStart Callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START with captureId: " + data);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_CAPTURE_START FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_CAPTURE_END
* @tc.name : Photo capture callback on capture end api
* @tc.desc : Photo capture callback on capture end api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_CAPTURE_END', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on capture end photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_CAPTURE_END to operate");
photoOutputPromise.on('captureEnd', async (err, data) => {
if (!err) {
console.info(TAG + "captureEnd callback is success");
if (data != null || data != undefined) {
console.info(TAG + "captureEnd callback with captureId: " + data.captureId);
console.info(TAG + "captureEnd callback with frameCount: " + data.frameCount);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + 'PHOTO_CAP_CALLBACK_ON_CAPTURE_END FAILED' + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER
* @tc.name : Photo capture callback on frame shutter api
* @tc.desc : Photo capture callback on frame shutter api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "Entering Photo capture callback on frame shutter photoOutput == null || undefined");
} else {
console.info(TAG + "Entering PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER to operate");
photoOutputPromise.on('frameShutter', async (err, data) => {
if (!err) {
console.info(TAG + "frameShutter callback is success");
if (data != null || data != undefined) {
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER with captureId: " + data.captureId);
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER with timestamp: " + data.timestamp);
expect(true).assertTrue();
}
} else {
expect().assertFail();
console.info(TAG + "PHOTO_CAP_CALLBACK_ON_FRAME_SHUTTER FAILED: " + err.message);
}
await sleep(1);
done();
})
await sleep(1);
done();
}
})
/**
* @tc.number : CAPTURE_SESSION_START_SUCCESS
* @tc.name : capture session start api
* @tc.desc : capture session start api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_START_SUCCESS', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + "Entering capture session start captureSession == null || undefined");
} else {
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS to operate");
await captureSessionPromise.start();
console.info(TAG + "Entering captureSession start success");
expect(true).assertTrue();
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS PASSED");
console.info(TAG + "Entering CAPTURE_SESSION_START_SUCCESS ends here");
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : isMirrorSupported_PHOTO_OUTPUT
* @tc.name : isMirrorSupported
* @tc.desc : isMirrorSupported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('isMirrorSupported_PHOTO_OUTPUT', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT to operate");
await photoOutputPromise.isMirrorSupported()
.then(function (data) {
console.info(TAG + "Entering isMirrorSupported_PHOTO_OUTPUT is success");
console.info(TAG + "isMirrorSupported : " + data);
expect(true).assertTrue();
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "isMirrorSupported_PHOTO_OUTPUT FAILED : " + err.message);
});
await sleep(1);
done();
}
await sleep(1);
done();
})
/**
* @tc.number : setMirror_true
* @tc.name : setMirror true
* @tc.desc : setMirror true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('setMirror_true', 0, async function (done) {
if (photoOutputPromise == null || photoOutputPromise == undefined) {
console.info(TAG + "photoOutput == null || undefined");
} else {
console.info(TAG + "Entering setMirror_true to operate");
await photoOutputPromise.setMirror(true)
.then(function (data) {
console.info(TAG + "Entering setMirror_true is success:");
console.info(TAG + "setMirror is : " + 'True');
expect(true).assertTrue();
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "setMirror_true FAILED : " + err.message);
});
await sleep(1);
done();
}
await sleep(1);
done();
})
//FLASH Function API scripts
/**
* @tc.number : HAS_FLASH
* @tc.name : check if has flash-camera0Input api
* @tc.desc : check if has flash-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('HAS_FLASH', 0, async function (done) {
console.info("--------------HAS_FLASH--------------");
console.info(TAG + 'hasFlash called.')
var hasFlashPromise = await camera0InputPromise.hasFlash();
console.info(TAG + "Entering HAS_FLASH success");
if (hasFlashPromise != null || hasFlashPromise != undefined) {
console.info(TAG + "Entering HAS_FLASH data is not null || undefined");
console.info(TAG + "Entering HAS_FLASH PASSED with HAS_FLASH is: " + JSON.stringify(hasFlashPromise));
expect(hasFlashPromise).assertEqual(true);
}
else {
console.info(TAG + "Entering HAS_FLASH FAILED : ");
expect().assertFail();
}
console.info(TAG + "Entering HAS_FLASH ends here");
await sleep(1)
done();
})
/**
* @tc.number : IS_FLASH_MODE_OPEN_SUPPORTED
* @tc.name : check if flash mode open is supported-camera0Input api
* @tc.desc : check if flash mode open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED to operate");
var isFMOpenSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED SUCCESS ");
if (isFMOpenSupported != null || isFMOpenSupported != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + JSON.stringify(isFMOpenSupported));
expect(isFMOpenSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_OPEN_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_OPEN
* @tc.name : set flash mode open camera0 api
* @tc.desc : set flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN to operate");
var SetFMOpen = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMOpen))
if (SetFMOpen == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_OPEN).assertEqual(1);
} else {
console.info(TAG + "Entering SET_FLASH_MODE_OPEN FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_OPEN ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_OPEN
* @tc.name : get flash mode open camera0 api
* @tc.desc : get flash mode open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_OPEN to operate");
var GetFMOpen = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_OPEN success: " + JSON.stringify(GetFMOpen));
if (GetFMOpen == 1) {
console.info(TAG + "GET_FLASH_MODE_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + JSON.stringify(GetFMOpen));
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_OPEN PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_OPEN FAILED : ");
console.info(TAG + "GET_FLASH_MODE_OPEN ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED to operate");
var isFMAlwaysOpenSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED SUCCESS ");
if (isFMAlwaysOpenSupported != null || isFMAlwaysOpenSupported != undefined) {
console.info(TAG + "Entering FLASH_MODE_ALWAYS_OPEN data is not null || undefined");
console.info(TAG + "FLASH_MODE_OPEN supported is: " + isFMAlwaysOpenSupported);
expect(isFMAlwaysOpenSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_ALWAYS_OPEN_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : set flash mode always open camera0 api
* @tc.desc : set flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN to operate");
var SetFMAlwaysOpen = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMAlwaysOpen))
if (SetFMAlwaysOpen == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN);
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_ALWAYS_OPEN).assertEqual(3)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_ALWAYS_OPEN
* @tc.name : get flash mode always open camera0 api
* @tc.desc : get flash mode always open camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_ALWAYS_OPEN', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN to operate");
var GetFMAlwaysOpen = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_ALWAYS_OPEN success");
if (GetFMAlwaysOpen == 3) {
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMAlwaysOpen);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN FAILED : ");
console.info(TAG + "GET_FLASH_MODE_ALWAYS_OPEN ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_AUTO_SUPPORTED
* @tc.name : check if flash mode always open is supported-camera0Input api
* @tc.desc : check if flash mode always open is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED to operate");
var isFMAutoSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED SUCCESS ");
if (isFMAutoSupported != null || isFMAutoSupported != undefined) {
console.info(TAG + "Entering FLASH_MODE_AUTO data is not null || undefined");
console.info(TAG + "FLASH_MODE_AUTO supported is: " + isFMAutoSupported);
expect(isFMAutoSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_AUTO
* @tc.name : set flash mode auto camera0 api
* @tc.desc : set flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO to operate");
var SetFMAlwaysAuto = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "SetFMAlwaysAuto: " + JSON.stringify(SetFMAlwaysAuto))
if (SetFMAlwaysAuto == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_AUTO);
console.info(TAG + "Entering SET_FLASH_MODE_AUTO PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_AUTO).assertEqual(2)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_AUTO FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_AUTO ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_AUTO
* @tc.name : get flash mode auto camera0 api
* @tc.desc : get flash mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_AUTO to operate");
var GetFMAuto = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_AUTO success");
if (GetFMAuto == 2) {
console.info(TAG + "GET_FLASH_MODE_AUTO data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMAuto);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_AUTO FAILED : ");
console.info(TAG + "GET_FLASH_MODE_AUTO ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : IS_FLASH_MODE_CLOSE_SUPPORTED
* @tc.name : check if flash mode close is supported-camera0Input api
* @tc.desc : check if flash mode close is supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FLASH_MODE_CLOSE_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED to operate");
var isFMCloseSupported = await camera0InputPromise.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED SUCCESS ");
if (isFMCloseSupported != null || isFMCloseSupported != undefined) {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED data is not null || undefined");
console.info(TAG + "FLASH_MODE_CLOSE supported is: " + isFMCloseSupported);
expect(isFMCloseSupported).assertEqual(true);
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FLASH_MODE_CLOSE_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FLASH_MODE_CLOSE
* @tc.name : set flash mode close camera0 api
* @tc.desc : set flash mode close camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE to operate");
var SetFMClose = await camera0InputPromise.setFlashMode(cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "setFlashModeOPEN: " + JSON.stringify(SetFMClose))
if (SetFMClose == undefined) {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE SUCCESS, current flashmode is: " + cameraObj.FlashMode.FLASH_MODE_CLOSE);
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE PASSED")
expect(cameraObj.FlashMode.FLASH_MODE_CLOSE).assertEqual(0)
} else {
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE FAILED : ");
expect().assertFail();
console.info(TAG + "Entering SET_FLASH_MODE_CLOSE ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : GET_FLASH_MODE_CLOSE
* @tc.name : get flash mode close camera0 api
* @tc.desc : get flash mode close camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FLASH_MODE_CLOSE', 0, async function (done) {
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE to operate");
var GetFMClose = await camera0InputPromise.getFlashMode();
console.info(TAG + "Entering GET_FLASH_MODE_CLOSE success");
if (GetFMClose == 0) {
console.info(TAG + "GET_FLASH_MODE_CLOSE data is not null || undefined: ");
console.info(TAG + "Current FlashMode is: " + GetFMClose);
expect(true).assertTrue();
console.info(TAG + "GET_FLASH_MODE_CLOSE PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FLASH_MODE_CLOSE FAILED : ");
console.info(TAG + "GET_FLASH_MODE_CLOSE ends here");
}
await sleep(1);
done();
})
//ZOOM Function
/**
* @tc.number : GET_ZOOM_RATIO_PROMISE
* @tc.name : get zoom ratio camera-0 cameraId api promise api
* @tc.desc : get zoom ratio camera-0 cameraId api promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_ZOOM_RATIO_PROMISE', 0, async function (done) {
console.info("--------------GET_ZOOM_RATIO_PROMISE--------------");
var getZoomRatioPromise = await camera0InputPromise.getZoomRatioRange();
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE getZoomRatioPromise: " + JSON.stringify(getZoomRatioPromise));
if (getZoomRatioPromise != null && getZoomRatioPromise != undefined) {
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE setZoomRatioPromise is not null || undefined");
expect(true).assertTrue();
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE success: " + JSON.stringify(getZoomRatioPromise));
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE PASSED");
} else {
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE FAILED");
expect().assertFail();
}
console.info(TAG + "Entering GET_ZOOM_RATIO_PROMISE ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_1_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_1_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(1);
console.info(TAG + "setZoomRatio success: 1");
console.info(TAG + "getZoomRatio called")
var getpromise1 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise1);
if (getpromise1 != null && getpromise1 != undefined) {
expect(getpromise1).assertEqual(1);
console.info(TAG + "SET_GET_ZOOM_1_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_1_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_2_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_2_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(2);
console.info(TAG + "setZoomRatio success: 2");
console.info(TAG + "getZoomRatio called")
var getpromise2 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise2);
if (getpromise2 != null && getpromise2 != undefined) {
expect(getpromise2).assertEqual(2);
console.info(TAG + "SET_GET_ZOOM_2_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_2_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_3_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_3_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(3);
console.info(TAG + "setZoomRatio success: 3");
console.info(TAG + "getZoomRatio called")
var getpromise3 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise3);
if (getpromise3 != null && getpromise3 != undefined) {
expect(getpromise3).assertEqual(3);
console.info(TAG + "SET_GET_ZOOM_3_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_3_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_4_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_4_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(4);
console.info(TAG + "setZoomRatio success: 4");
console.info(TAG + "getZoomRatio called")
var getpromise4 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise4);
if (getpromise4 != null && getpromise4 != undefined) {
expect(getpromise4).assertEqual(4);
console.info(TAG + "SET_GET_ZOOM_4_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_4_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_5_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_5_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(5);
console.info(TAG + "setZoomRatio success: 5");
console.info(TAG + "getZoomRatio called")
var getpromise5 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise5);
if (getpromise5 != null && getpromise5 != undefined) {
expect(getpromise5).assertEqual(5);
console.info(TAG + "SET_GET_ZOOM_5_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_5_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
/**
* @tc.number : SET_GET_ZOOM_6_PROMISE
* @tc.name : Zoom camera-0 cameraId api
* @tc.desc : Zoom camera-0 cameraId api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_GET_ZOOM_6_PROMISE', 0, async function (done) {
var setpromise = await camera0InputPromise.setZoomRatio(6);
console.info(TAG + "setZoomRatio success: 6");
console.info(TAG + "getZoomRatio called")
var getpromise6 = await camera0InputPromise.getZoomRatio();
console.info(TAG + "getZoomRatio success: " + getpromise6);
if (getpromise6 != null && getpromise6 != undefined) {
expect(getpromise6).assertEqual(6);
console.info(TAG + "SET_GET_ZOOM_6_PROMISE PASSED ");
}
else {
console.info(TAG + "SET_GET_ZOOM_6_PROMISE FAILED");
expect().assertFail();
}
await sleep(1);
done();
})
// FOCUS promise API's
/**
* @tc.number : IS_FOCUS_MODE_LOCKED_SUPPORTED
* @tc.name : check is focus mode locked supported-camera0Input api
* @tc.desc : check is focus mode locked supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED to operate");
var isFMLockedSupported = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering is focus mode locked supported SUCCESS ");
if (isFMLockedSupported != null || isFMLockedSupported != undefined) {
console.info(TAG + "Entering is focus mode locked supported data is not null || undefined");
console.info(TAG + "is focus mode locked supported : " + isFMLockedSupported);
expect(isFMLockedSupported).assertEqual(false);
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED PASSED");
}
else {
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "Entering IS_FOCUS_MODE_LOCKED_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_LOCKED
* @tc.name : set focus mode locked camera0 api
* @tc.desc : set focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_LOCKED)
.then(function (data) {
console.info(TAG + "SetFMLocked: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode locked SUCCESS, current focusmode is: " + cameraObj.FocusMode.FOCUS_MODE_LOCKED);
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED FAILED : ")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
console.info(TAG + "Entering SET_FOCUS_MODE_LOCKED ends here");
});
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_LOCKED
* @tc.name : get focus mode locked camera0 api
* @tc.desc : get focus mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_LOCKED to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode locked success: ");
if (data == 0) {
console.info(TAG + "Current focusmode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_LOCKED PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_LOCKED FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_LOCKED ends here");
});
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCAL_LENGTH
* @tc.name : get focal length camera0 api
* @tc.desc : get focal length camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCAL_LENGTH', 0, async function (done) {
console.info(TAG + "Entering GET_FOCAL_LENGTH to operate");
await camera0InputPromise.getFocalLength()
.then(function (data) {
console.info(TAG + "Current focallength is: " + JSON.stringify(data));
expect(data).assertEqual(3.4600000381469727);
console.info(TAG + "GET_FOCAL_LENGTH PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCAL_LENGTH FAILED : " + err.message);
});
console.info(TAG + "GET_FOCAL_LENGTH ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_MANUAL_SUPPORTED
* @tc.name : is focusmode manual supported
* @tc.desc : is focusmode manual supported
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_MANUAL_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED to operate");
var isFMmanualSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_MANUAL);
if (isFMmanualSupportedpromise != null || isFMmanualSupportedpromise != undefined) {
console.info(TAG + "Entering is focusmode manual supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_MANUAL_SUPPORTED is: " + isFMmanualSupportedpromise);
expect(isFMmanualSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_MANUAL_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_MANUAL_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_MANUAL
* @tc.name : set focus mode manual camera0 api
* @tc.desc : set focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL)
.then(function (data) {
console.info(TAG + "setFocusManual: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode manual SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_MANUAL);
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_MANUAL).assertEqual(0)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_MANUAL ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_MANUAL
* @tc.name : get focus mode manual camera0 api
* @tc.desc : get focus mode manual camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_MANUAL', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_MANUAL to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode manual SUCCESS");
if (data == 0) {
console.info(TAG + "Current FocusMode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_MANUAL PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_MANUAL FAILED : " + err.message);
console.info(TAG + "GET_FOCUS_MODE_MANUAL ends here");
});
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point1)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current focusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_CONTINUOUS_SUPPORTED
* @tc.name : check is focus mode continuous supported-camera0Input api
* @tc.desc : check is focus mode continuous supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_CONTINUOUS_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED to operate");
var isFMContinuousSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
if (isFMContinuousSupportedpromise != null || isFMContinuousSupportedpromise != undefined) {
console.info(TAG + "Entering is focus mode continuous supported data is not null || undefined");
console.info(TAG + "FOCUS_MODE_CONTINUOUS_SUPPORTED is: " + isFMContinuousSupportedpromise);
expect(isFMContinuousSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_CONTINUOUS_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_CONTINUOUS_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_CONTINUOUS
* @tc.name : set focus mode continuous camera0 api
* @tc.desc : set focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS to operate");
await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO)
.then(function (data) {
console.info(TAG + "setFocusCont: " + JSON.stringify(data))
console.info(TAG + "Entering set focus mode continuous SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_CONTINUOUS_AUTO).assertEqual(1)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_CONTINUOUS ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_CONTINUOUS
* @tc.name : get focus mode continuous camera0 api
* @tc.desc : get focus mode continuous camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_CONTINUOUS', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_CONTINUOUS to operate");
await camera0InputPromise.getFocusMode()
.then(function (data) {
console.info(TAG + "Entering get focus mode continuous SUCCESS");
if (data == 1) {
console.info(TAG + "Current FocusMode is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS PASSED");
}
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS FAILED: " + err.message);
});
console.info(TAG + "GET_FOCUS_MODE_CONTINUOUS ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point2)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is:" + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current FocusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_FOCUS_MODE_AUTO_SUPPORTED
* @tc.name : check is focus mode auto supported-camera0Input api
* @tc.desc : check is focus mode auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('IS_FOCUS_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED to operate");
var isFMAutoSupportedpromise = await camera0InputPromise.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO);
if (isFMAutoSupportedpromise != null || isFMAutoSupportedpromise != undefined) {
console.info(TAG + "Entering is focus mode auto supported data is not null || undefined");
console.info(TAG + "is focus mode auto supported is: " + isFMAutoSupportedpromise);
expect(isFMAutoSupportedpromise).assertEqual(true);
console.info(TAG + "Entering IS_FOCUS_MODE_AUTO_SUPPORTED PASSED: ");
}
else {
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED FAILED : ");
expect().assertFail();
console.info(TAG + "IS_FOCUS_MODE_AUTO_SUPPORTED ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_MODE_AUTO
* @tc.name : set focus mode auto camera0 api
* @tc.desc : set focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO to operate");
var setFocusAuto = await camera0InputPromise.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_AUTO)
.then(function () {
console.info(TAG + "setFocusAuto: " + JSON.stringify(setFocusAuto))
console.info(TAG + "Entering set focus mode auto SUCCESS, current FocusMode is: " + cameraObj.FocusMode.FOCUS_MODE_AUTO);
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO PASSED")
expect(cameraObj.FocusMode.FOCUS_MODE_AUTO).assertEqual(2)
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO FAILED : ");
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_MODE_AUTO ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_MODE_AUTO
* @tc.name : get focus mode auto camera0 api
* @tc.desc : get focus mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_MODE_AUTO to operate");
var getfocusmodepromise = await camera0InputPromise.getFocusMode();
console.info(TAG + "Entering get focus mode auto SUCCESS");
if (getfocusmodepromise == 2) {
console.info(TAG + "Current FocusMode is: " + getfocusmodepromise);
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_MODE_AUTO PASSED");
}
else {
expect().assertFail();
console.info(TAG + "GET_FOCUS_MODE_AUTO FAILED : ");
console.info(TAG + "GET_FOCUS_MODE_AUTO ends here");
}
await sleep(1);
done();
})
/**
* @tc.number : SET_FOCUS_POINT
* @tc.name : set focus Point camera0 api
* @tc.desc : set focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering set focus mode locked to operate");
await camera0InputPromise.setFocusPoint(Point3)
.then(function (data) {
console.info(TAG + "Entering set focus Point SUCCESS, current focusPoint is:" + JSON.stringify(data));
console.info(TAG + "Entering SET_FOCUS_POINT PASSED");
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_FOCUS_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_FOCUS_POINT
* @tc.name : get focus Point camera0 api
* @tc.desc : get focus Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_FOCUS_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_FOCUS_POINT to operate");
await camera0InputPromise.getFocusPoint()
.then(function (data) {
console.info(TAG + "Current focusPoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_FOCUS_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_FOCUS_POINT FAILED : " + err.message);
});
console.info(TAG + "GET_FOCUS_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_LOCKED_SUPPORTED
* @tc.name : check is exposure mode locked supported-camera0Input api
* @tc.desc : check is exposure mode locked supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_LOCKED_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_LOCKED_SUPPORTED PASSED: " + data);
expect(data).assertEqual(false);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_LOCKED_SUPPORTED ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_LOCKED
* @tc.name : set exposure mode locked camera0 api
* @tc.desc : set exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_Locked to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_LOCKED);
console.info(TAG + "Entering SET_EXPOSURE_MODE_Locked FAILED")
expect().assertFail()
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_LOCKED ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_LOCKED
* @tc.name : get exposure mode locked camera0 api
* @tc.desc : get exposure mode locked camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_MODE_LOCKED', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_LOCKED to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode locked SUCCESS");
console.info(TAG + "Current ExposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_LOCKED ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode locked
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_Point to operate");
await camera0InputPromise.setExposurePoint(Point1)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode locked
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_BIASRANGE_exposure mode locked
* @tc.name : get exposure bias range camera0 api
* @tc.desc : get exposure bias range camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_BIASRANGE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_BIASRANGE to operate");
await camera0InputPromise.getExposureBiasRange()
.then(function (data) {
console.info(TAG + "Entering getExposureBiasRange SUCCESS");
console.info(TAG + "Current ExposureBiasRange is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_BIASRANGE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_BIASRANGE FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_BIASRANGE ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode locked
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(-4)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_VALUE_exposure mode locked
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(-4);
console.info(TAG + "GET_EXPOSURE_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_VALUE ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_AUTO_SUPPORTED
* @tc.name : check is exposure mode auto supported-camera0Input api
* @tc.desc : check is exposure mode auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_AUTO_SUPPORTED', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_AUTO_SUPPORTED PASSED: " + data);
expect(data).assertEqual(true);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED FAILED: " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_AUTO_SUPPORTED ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_AUTO
* @tc.name : set exposure mode auto camera0 api
* @tc.desc : set exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO PASSED")
expect(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO).assertEqual(1);
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_AUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_AUTO
* @tc.name : get exposure mode auto camera0 api
* @tc.desc : get exposure mode auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('GET_EXPOSURE_MODE_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_AUTO to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode auto SUCCESS");
console.info(TAG + "Current exposureMode is: " + data);
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_MODE_AUTO PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_AUTO FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_AUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_POINT_exposure mode auto
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
await camera0InputPromise.setExposurePoint(Point2)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED: " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT_exposure mode auto
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED: " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(1)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_VALUE_exposure mode auto
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(1);
console.info(TAG + "GET_EXPOSURE_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_VALUE ends here");
await sleep(1);
done();
})
/**
* @tc.number : IS_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : check is exposure mode continuous auto supported-camera0Input api
* @tc.desc : check is exposure mode continuous auto supported-camera0Input api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('IS_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
await camera0InputPromise.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO)
.then(function (data) {
console.info(TAG + "Entering IS_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED: " + data);
expect(data).assertEqual(false);
})
.catch((err) => {
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "IS_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : set exposure mode continuous auto camera0 api
* @tc.desc : set exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('SET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
await camera0InputPromise.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO)
.then(function () {
console.info(TAG + "Entering set exposure mode auto SUCCESS, current ExposureMode is: " + cameraObj.ExposureMode.EXPOSURE_MODE_CONTINUOUS_AUTO);
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED")
expect().assertFail();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED : " + err.message);
expect(true).assertTrue();
});
console.info(TAG + "Entering SET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : GET_EXPOSURE_MODE_CONTINUOUS_AUTO
* @tc.name : get exposure mode continuous auto camera0 api
* @tc.desc : get exposure mode continuous auto camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
/* EXPOSUREMODE Interface will be change
it('GET_EXPOSURE_MODE_CONTINUOUS_AUTO', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_MODE_CONTINUOUS_AUTO to operate");
await camera0InputPromise.getExposureMode()
.then(function (data) {
console.info(TAG + "Entering get exposure mode auto SUCCESS");
console.info(TAG + "Current exposureMode is: " + data);
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_MODE_CONTINUOUS_AUTO ends here");
await sleep(1);
done();
})
*/
/**
* @tc.number : SET_EXPOSURE_POINT
* @tc.name : set exposure Point camera0 api
* @tc.desc : set exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_POINT to operate");
await camera0InputPromise.setExposurePoint(Point3)
.then(function (data) {
console.info(TAG + "Entering set exposure Point SUCCESS, current ExposurePoint is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_POINT PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_POINT FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_POINT
* @tc.name : get exposure Point camera0 api
* @tc.desc : get exposure Point camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_POINT', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_POINT to operate");
await camera0InputPromise.getExposurePoint()
.then(function (data) {
console.info(TAG + "Entering getExposurePoint SUCCESS");
console.info(TAG + "Current ExposurePoint is: " + JSON.stringify(data));
expect(true).assertTrue();
console.info(TAG + "GET_EXPOSURE_POINT PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_POINT FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_POINT ends here");
await sleep(1);
done();
})
/**
* @tc.number : SET_EXPOSURE_BIAS_exposure mode continuous auto
* @tc.name : set exposure bias camera0 api
* @tc.desc : set exposure bias camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SET_EXPOSURE_BIAS', 0, async function (done) {
console.info(TAG + "Entering SET_EXPOSURE_BIAS to operate");
await camera0InputPromise.setExposureBias(4)
.then(function (data) {
console.info(TAG + "Entering set exposure bias SUCCESS, current Exposurebias is: " + JSON.stringify(data));
console.info(TAG + "Entering SET_EXPOSURE_BIAS PASSED")
expect(true).assertTrue();
})
.catch((err) => {
console.info(TAG + "Entering SET_EXPOSURE_BIAS FAILED : " + err.message);
expect().assertFail();
});
console.info(TAG + "Entering SET_EXPOSURE_BIAS ends here");
await sleep(1);
done();
})
/**
* @tc.number : GET_EXPOSURE_VALUE
* @tc.name : get exposure value camera0 api
* @tc.desc : get exposure value camera0 api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('GET_EXPOSURE_VALUE', 0, async function (done) {
console.info(TAG + "Entering GET_EXPOSURE_VALUE to operate");
await camera0InputPromise.getExposureValue()
.then(function (data) {
console.info(TAG + "Entering getExposureValue SUCCESS");
console.info(TAG + "Current ExposureValue is: " + JSON.stringify(data));
expect(data).assertEqual(4);
console.info(TAG + "GET_EXPOSURE_VALUE PASSED");
})
.catch((err) => {
expect().assertFail();
console.info(TAG + "GET_EXPOSURE_VALUE FAILED : " + err.message);
});
console.info(TAG + "GET_EXPOSURE_VALUE ends here");
await sleep(1);
done();
})
/**
* @tc.number : VIDEO_OUTPUT_START_PROMISE
* @tc.name : VideoOutput start promise api
* @tc.desc : VideoOutput start promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_START_PROMISE', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + 'Entering Video Output start videoOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_START_PROMISE to operate')
await videoOutputPromise.start()
expect(true).assertTrue()
console.info(TAG + 'Entering VIDEO_OUTPUT_START_PROMISE PASSED')
console.info(TAG + 'Entering VIDEO_OUTPUT_START_PROMISE ends here')
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : VIDEO_OUTPUT_STOP_PROMISE
* @tc.name : VideoOutput stop promise api
* @tc.desc : VideoOutput stop promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEO_OUTPUT_STOP_PROMISE', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + 'Entering Video Output Stop videoOutputPromise == null || undefined')
} else {
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP_PROMISE to operate')
await videoOutputPromise.stop()
expect(true).assertTrue()
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP_PROMISE PASSED')
console.info(TAG + 'Entering VIDEO_OUTPUT_STOP_PROMISE ends here')
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : CAPTURE_SESSION_STOP_PROMISE
* @tc.name : CaptureSession stop promise api
* @tc.desc : CaptureSession stop promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_STOP_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + 'Entering Capture Session Stop captureSessionPromise == null || undefined')
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_STOP_PROMISE to operate')
await captureSessionPromise.stop()
expect(true).assertTrue()
console.info(TAG + 'Entering CAPTURE_SESSION_STOP_PROMISE PASSED')
console.info(TAG + 'Entering CAPTURE_SESSION_STOP_PROMISE ends here')
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : CAPTURE_SESSION_RELEASE_PROMISE
* @tc.name : CaptureSession release promise api
* @tc.desc : CaptureSession release promise api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAPTURE_SESSION_RELEASE_PROMISE', 0, async function (done) {
if (captureSessionPromise == null || captureSessionPromise == undefined) {
console.info(TAG + 'Entering Capture session release captureSessionPromise == null || undefined')
} else {
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE_PROMISE to operate')
await captureSessionPromise.release()
expect(true).assertTrue()
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE_PROMISE PASSED')
console.info(TAG + 'Entering CAPTURE_SESSION_RELEASE_PROMISE ends here')
await sleep(1)
done()
}
await sleep(1)
done()
})
/**
* @tc.number : VIDEOOUTPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : videoOutput release api
* @tc.desc : videoOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('VIDEOOUTPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (videoOutputPromise == null || videoOutputPromise == undefined) {
console.info(TAG + "Entering Video Output release previewOutputPromise == null || undefined");
} else {
console.info(TAG + "Entering VIDEOOUTPUT_RELEASE_SUCCESS_PROMISE to operate");
await videoOutputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering VIDEOOUTPUT_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering VIDEOOUTPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1)
done()
})
/**
* @tc.number : PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : PreviewOutput release api
* @tc.desc : PreviewOutput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (previewOutputPromise == null || previewOutputPromise == undefined) {
console.info(TAG + "Entering previewOutputPromise.release previewOutputPromise == null || undefined");
} else {
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE to operate");
await previewOutputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering PREVIEWOUTPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1)
done()
})
/**
* @tc.number : CAMERAINPUT_RELEASE_SUCCESS_PROMISE
* @tc.name : cameraInput release api
* @tc.desc : cameraInput release api
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('CAMERAINPUT_RELEASE_SUCCESS_PROMISE', 0, async function (done) {
if (camera0InputPromise == null || camera0InputPromise == undefined) {
console.info(TAG + "Entering camera0InputPromise.release camera0InputPromise == null || undefined");
} else {
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISE to operate");
await camera0InputPromise.release();
expect(true).assertTrue();
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISE PASSED");
console.info(TAG + "Entering CAMERAINPUT_RELEASE_SUCCESS_PROMISE ends here");
await sleep(1);
done();
}
await sleep(1)
done()
})
})
}
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或