!7117 Xts camera error code test case

Merge pull request !7117 from 马利/master

multimedia/camera/camera_js_standard/entry/src/main/ets/test/Camera.test.ets

@@ -22,9 +22,11 @@ import cameraSessionZoomRatioTest from './CameraSessionZoomRatioTest.test.ets'
 import cameraSessionVideoStabilizationTest from './CameraSessionVideoStabilizationTest.test.ets'
 import cameraSessionBaseTest from './CameraSessionBaseTest.test.ets'
 import cameraInputTest from './CameraInputTest.test.ets'
+import CameraErrorCodeUsecaseTest from './CameraErrorCodeUsecaseTest.test.ets'
 import cameraManagerTest from './CameraManagerTest.test.ets'
 import cameraEnumTest from './CameraEnumTest.test.ets'
 
+
 let TAG = 'CameraModuleTest: '
 
 export default function cameraKit() {
@@ -37,6 +39,7 @@ export default function cameraKit() {
   cameraSessionZoomRatioTest()
   cameraSessionVideoStabilizationTest()
   cameraSessionBaseTest()
+  CameraErrorCodeUsecaseTest()
   cameraManagerTest()
   cameraEnumTest()
 }
\ No newline at end of file

multimedia/camera/camera_js_standard/entry/src/main/ets/test/CameraErrorCodeUsecaseTest.test.ets

+/*
+ * 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 media from '@ohos.multimedia.media';
+import mediaLibrary from '@ohos.multimedia.mediaLibrary';
+import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from '@ohos/hypium';
+
+// 创建视频录制的参数
+let videoProfile = {
+    audioBitrate: 48000,
+    audioChannels: 2,
+    audioCodec: 'audio/mp4a-latm',
+    audioSampleRate: 48000,
+    fileFormat: 'mp4',
+    videoBitrate: 48000,
+    videoCodec: 'video/mp4v-es',
+    videoFrameWidth: 640,
+    videoFrameHeight: 480,
+    videoFrameRate: 30
+  }
+
+let videoConfig = {
+    audioSourceType: 1,
+    videoSourceType: 0,
+    profile: videoProfile,
+    url: 'file:///data/media/CameraOutput.mp4',
+    orientationHint: 0,
+    location: { latitude: 30, longitude: 130 },
+    maxSize: 100,
+    maxDuration: 500
+  }
+
+  let captureLocation = {
+    latitude: 0,
+    longitude: 0,
+    altitude: 0,
+  }
+
+  let captureSetting = {
+    quality: cameraObj.QualityLevel.QUALITY_LEVEL_LOW,
+    rotation: cameraObj.ImageRotation.ROTATION_0,
+    location: captureLocation,
+    mirror: false
+  }
+
+const TAG = "CameraErrorCodeUsecaseTest: ";
+let mCameraManager;
+let cameraOutputCap;
+let mCameraDevicesArray;
+let mCameraSession;
+let mCameraNum;
+let mCameraInput;
+let mPreviewOutput;
+let mPhotoSurface;
+let mPhotoOutput;
+let videoOutput;
+let videoRecorder;
+let videoSurfaceId;
+let fdPath;
+let fileAsset;
+let fdNumber;
+let metadataOutput;
+let mMetadataObjectTypeArray;
+
+export default function CameraErrorCodeUsecaseTest() {
+    function sleep(ms) {
+        console.info(TAG + "Entering sleep -> Promise constructor");
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    function isEmpty(data) {
+        if (data == null || data == undefined) {
+            return true;
+        }
+        return false;
+    }
+
+    function getCameraManagerInstance() {
+        console.info(TAG + 'Enter getCameraManagerInstance');
+        mCameraManager = cameraObj.getCameraManager(null);
+        if (isEmpty(mCameraManager)) {
+            console.info(TAG + "getCameraManager FAILED");
+            return false;
+        }
+        console.info(TAG + 'Exit getCameraManagerInstance');
+        return true;
+    }
+
+    function getCameraSupportDevicesArray() {
+        console.info(TAG + 'Enter getCameraSupportDevicesArray');
+        mCameraDevicesArray = mCameraManager.getSupportedCameras();
+        if (isEmpty(mCameraDevicesArray)) {
+            console.info(TAG + "getSupportedCameras FAILED");
+            return false;
+        }
+        mCameraNum = mCameraDevicesArray.length;
+        console.info(TAG + "getCameraSupportDevicesArray is: " + mCameraNum);
+        console.info(TAG + 'Exit getCameraSupportDevicesArray');
+        return true;
+    }
+
+    async function createInput(idx:any) {
+        console.info(TAG + 'Enter createInput');
+        if (isEmpty(mCameraDevicesArray)) {
+            console.info(TAG + "Entering createInputs FAILED with NoCamera");
+            return false;
+        }
+        mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[idx]);
+        if (isEmpty(mCameraInput)) {
+            console.info(TAG + "createCameraInput FAILED");
+            return false;
+        }
+        await mCameraInput.open();
+        sleep(100);
+        console.info(idx + 'th CameraInput is: ' + mCameraInput);
+        console.info(TAG + 'Exit createInput');
+        return true;
+    }
+
+    function releaseInput() {
+        console.info(TAG + 'Enter releaseInput');
+
+        if (!isEmpty(mCameraInput)) {
+            mCameraInput.close();
+        }
+
+        console.info(TAG + 'Exit releaseInput');
+
+        return true;
+    }
+
+    function beginCameraSessionConfig() {
+        console.info(TAG + 'Enter beginCameraSessionConfig');
+        mCameraSession.beginConfig();
+        console.info(TAG + 'Exit beginCameraSessionConfig');
+        return true;
+    }
+
+    async function commitCameraSessionConfig() {
+        console.info(TAG + 'Enter commitCameraSessionConfig');
+        await mCameraSession.commitConfig();
+        sleep(500);
+        console.info(TAG + 'Exit commitCameraSessionConfig');
+        return true;
+    }
+
+    function createCameraSessionInstance() {
+        console.info(TAG + 'Enter createCameraSessionInstance');
+        try {
+            mCameraSession = mCameraManager.createCaptureSession();
+        }
+        catch {
+            console.info(TAG + 'createCaptureSession FAILED');
+        }
+        if (isEmpty(mCameraSession)) {
+            console.info(TAG + "createCaptureSession FAILED");
+            return false;
+        }
+        beginCameraSessionConfig();
+        console.info(TAG + 'Exit createCameraSessionInstance');
+        return true;
+    }
+
+    function releaseCameraSessionInstance() {
+        mCameraSession.release();
+    }
+
+    async function getPhotoReceiverSurface() {
+        console.log(TAG + 'Entering getPhotoReceiverSurface')
+        let receiver = image.createImageReceiver(640, 480, 4, 8)
+        console.log(TAG + 'before receiver check')
+        if (receiver !== undefined) {
+            console.log(TAG + 'Photo receiver is created successfully')
+            mPhotoSurface = await receiver.getReceivingSurfaceId()
+            console.log(TAG + 'Photo received id: ' + JSON.stringify(mPhotoSurface))
+        } else {
+            console.log(TAG + 'Photo receiver is created failed')
+        }
+        console.log(TAG + 'Exit getPhotoReceiverSurface')
+    }
+
+    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('ErrorCodeCameraOutput.mp4');
+        videoConfig.url = fdPath;
+        media.createVideoRecorder((err, recorder) => {
+          if (!err) {
+            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) => {
+              if (!err) {
+                console.info(TAG + 'videoRecorder.prepare success.')
+                videoRecorder.getInputSurface((err, id) => {
+                  console.info(TAG + 'getInputSurface called')
+                  if (!err) {
+                    videoSurfaceId = id
+                    console.info(TAG + 'getInputSurface surfaceId: ' + JSON.stringify(videoSurfaceId))
+                  } else {
+                    console.info(TAG + 'getInputSurface FAILED')
+                  }
+                })
+              } else {
+                console.info(TAG + 'prepare FAILED')
+              }
+            })
+          }
+          else {
+            console.info(TAG + 'createVideoRecorder FAILED')
+          }
+        })
+      }
+
+    async function releaseVideoReceiveSurface() {
+        console.log(TAG + 'Entering releaseVideoReceiveSurface')
+        videoRecorder.release((err) => {
+            console.info(TAG + 'Entering release video receiver')
+        })
+        await closeFd();
+        console.log(TAG + 'Exit releaseVideoReceiveSurface')
+    }
+
+    function createOutput(idx:any) {
+        console.info(TAG + 'Enter createOutput');
+        cameraOutputCap = mCameraManager.getSupportedOutputCapability(mCameraDevicesArray[idx]);
+        if (!isEmpty(cameraOutputCap)) {
+            if (!isEmpty(cameraOutputCap.previewProfiles)) {
+                console.info(TAG + "cameraOutputCap.previewProfiles.length: " + cameraOutputCap.previewProfiles.length);      
+                for (let i = 0; i < cameraOutputCap.previewProfiles.length; i++) {
+                    mPreviewOutput = mCameraManager.createPreviewOutput(cameraOutputCap.previewProfiles[i], globalThis.surfaceId);
+                    if (!isEmpty(mPreviewOutput)) {
+                        break;
+                    }
+                }
+                if (isEmpty(mPreviewOutput)) {
+                    console.info(TAG + "createPreviewOutput FAILED");
+                }
+                console.info(TAG + "createPreviewOutput: " + mPreviewOutput);
+            }
+        }
+        if (!isEmpty(cameraOutputCap.photoProfiles)) {
+            console.info(TAG + "cameraOutputCap.photoProfiles.length: " + cameraOutputCap.photoProfiles.length);   
+                
+            for (let i = 0; i < cameraOutputCap.photoProfiles.length; i++) {
+                mPhotoOutput = mCameraManager.createPhotoOutput(cameraOutputCap.photoProfiles[i], mPhotoSurface);
+                if (!isEmpty(mPhotoOutput)) {
+                    break;
+                }
+            }
+            if (isEmpty(mPhotoOutput)) {
+                console.info(TAG + "createPhotoOutput FAILED");
+            }
+            console.info(TAG + "createPhotoOutput: " + mPhotoOutput);
+        }
+        if (!isEmpty(cameraOutputCap.supportedMetadataObjectTypes)) {
+            mMetadataObjectTypeArray = cameraOutputCap.supportedMetadataObjectTypes;
+            if (isEmpty(mMetadataObjectTypeArray)) {
+                console.info(TAG + "mMetadataObjectTypeArray is null");
+            } else {
+                console.info(TAG + "createMetadataOutput")
+                metadataOutput = mCameraManager.createMetadataOutput(mMetadataObjectTypeArray);
+            }
+        }
+        console.info(TAG + 'Exit createOutputs');
+        return true;
+    }
+
+    describe('CameraErrorCodeUsecaseTest', function () {
+        console.info(TAG + '----------CameraErrorCodeUsecaseTest--------------');
+        beforeAll(async function () {
+            await getPhotoReceiverSurface();
+            await getvideosurface();
+            getCameraManagerInstance();
+            getCameraSupportDevicesArray();
+            console.info(TAG + 'beforeAll case');
+        })
+
+        beforeEach(function () {
+            sleep(1000);
+            console.info('beforeEach case');
+        })
+
+        afterEach(async function () {
+            console.info('afterEach case');
+        })
+
+        afterAll(function () {
+            releaseVideoReceiveSurface();
+            sleep(1000);
+            console.info('afterAll case');
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100
+         * @tc.name      : createCameraInput api
+         * @tc.desc      : createCameraInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let camerainput = mCameraManager.createCameraInput();
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200
+         * @tc.name      : createCameraInput api
+         * @tc.desc      : createCameraInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let camerainput = mCameraManager.createCameraInput("cameraInput");
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300
+         * @tc.name      : createCameraInput api
+         * @tc.desc      : createCameraInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let camerainput = mCameraManager.createCameraInput(null,"cameraInput");
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400
+         * @tc.name      : createCameraInput api
+         * @tc.desc      : createCameraInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let camerainput = mCameraManager.createCameraInput(null);
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100
+         * @tc.name      : createPreviewOutput api
+         * @tc.desc      : createPreviewOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let previewoutput = mCameraManager.createPreviewOutput(null);
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200
+         * @tc.name      : createPreviewOutput api
+         * @tc.desc      : createPreviewOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let previewoutput = mCameraManager.createPreviewOutput(null,"createoutput");
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100
+         * @tc.name      : createPhotoOutput api
+         * @tc.desc      : createPhotoOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let photooutput = mCameraManager.createPhotoOutput(null,"createoutput");
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200
+         * @tc.name      : createPhotoOutput api
+         * @tc.desc      : createPhotoOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let photooutput = mCameraManager.createPhotoOutput(null);
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100
+         * @tc.name      : createVideoOutput api
+         * @tc.desc      : createVideoOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let videooutput = mCameraManager.createVideoOutput(null);
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200
+         * @tc.name      : createVideoOutput api
+         * @tc.desc      : createVideoOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let videooutput = mCameraManager.createVideoOutput(null,"createoutput");
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100
+         * @tc.name      : createMetadataOutput api
+         * @tc.desc      : createMetadataOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let videooutput = mCameraManager.createMetadataOutput(null);
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200
+         * @tc.name      : createMetadataOutput api
+         * @tc.desc      : createMetadataOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200--------------");
+            if (isEmpty(mCameraManager)) {
+                console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200 cameraManager == null || undefined")
+                expect().assertFail();
+                done();
+              } else {
+                try {
+                    let metadataoutput = mCameraManager.createMetadataOutput();
+                } catch (error) {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + error.code);
+                    expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+                done();
+              }
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100
+         * @tc.name      : addInput api
+         * @tc.desc      : addInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.addInput(null);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200
+         * @tc.name      : addInput api
+         * @tc.desc      : addInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.addInput();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100
+         * @tc.name      : removeInput api
+         * @tc.desc      : removeInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.removeInput();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200
+         * @tc.name      : removeInput api
+         * @tc.desc      : removeInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.removeInput(null);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100
+         * @tc.name      : addOutput api
+         * @tc.desc      : addOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.addOutput();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200
+         * @tc.name      : addOutput api
+         * @tc.desc      : addOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.addOutput(null);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100
+         * @tc.name      : removeOutput api
+         * @tc.desc      : removeOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.removeOutput();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200
+         * @tc.name      : removeOutput api
+         * @tc.desc      : removeOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200--------------");
+            createCameraSessionInstance();
+            try {
+                mCameraSession.removeOutput(null);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            await mCameraSession.start();
+            mPhotoOutput.capture({},async (err) => {
+                if (!err) {
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                    expect(true).assertTrue();
+                }
+            })
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            await mCameraSession.start();
+            await mPhotoOutput.capture({}).then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                expect(err.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue();
+                expect(true).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100
+         * @tc.name      : commitConfig api
+         * @tc.desc      : commitConfig api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            mCameraSession.commitConfig(async (err) => {
+                if (!err) {
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                    expect(true).assertTrue();
+                }
+            })
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200
+         * @tc.name      : commitConfig api
+         * @tc.desc      : commitConfig api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            await mCameraSession.commitConfig().then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                expect(err.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                expect(true).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300
+         * @tc.name      : addInput api
+         * @tc.desc      : addInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            try {
+                mCameraSession.addInput(mCameraInput);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300
+         * @tc.name      : removeInput api
+         * @tc.desc      : removeInput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            try {
+                mCameraSession.removeInput(mCameraInput);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300
+         * @tc.name      : addOutput api
+         * @tc.desc      : addOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            createOutput(0);
+            try {
+                mCameraSession.addOutput(mPreviewOutput);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300
+         * @tc.name      : removeOutput api
+         * @tc.desc      : removeOutput api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            createOutput(0);
+            try {
+                mCameraSession.removeOutput(mPreviewOutput);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100
+         * @tc.name      : capturesession start api
+         * @tc.desc      : capturesession start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            mCameraSession.start().then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG);
+                expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200
+         * @tc.name      : capturesession start api
+         * @tc.desc      : capturesession start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            mCameraSession.start(async (err) => {
+                if (!err) {
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                }
+            })
+            sleep(1000);
+            releaseInput();
+            sleep(1000);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100
+         * @tc.name      : capturesession hasFlash api
+         * @tc.desc      : capturesession hasFlash api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let isFlash = mCameraSession.hasFlash();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+            };
+            sleep(1000);
+            releaseInput();
+            sleep(1000);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100
+         * @tc.name      : capturesession isFlashModeSupported api
+         * @tc.desc      : capturesession isFlashModeSupported api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let isFlashmodesupported = mCameraSession.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100
+         * @tc.name      : capturesession getFlashMode api
+         * @tc.desc      : capturesession getFlashMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let flashmode = mCameraSession.getFlashMode();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100
+         * @tc.name      : capturesession setFlashMode api
+         * @tc.desc      : capturesession setFlashMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100
+         * @tc.name      : capturesession isExposureModeSupported api
+         * @tc.desc      : capturesession isExposureModeSupported api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let issupported = mCameraSession.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100
+         * @tc.name      : capturesession getExposureMode api
+         * @tc.desc      : capturesession getExposureMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let exposure = mCameraSession.getExposureMode();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100
+         * @tc.name      : capturesession setExposureMode api
+         * @tc.desc      : capturesession setExposureMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+            };
+            sleep(1000);
+            releaseInput();
+            sleep(1000);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100
+         * @tc.name      : capturesession getMeteringPoint api
+         * @tc.desc      : capturesession getMeteringPoint api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let point = mCameraSession.getMeteringPoint();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100
+         * @tc.name      : capturesession setMeteringPoint api
+         * @tc.desc      : capturesession setMeteringPoint api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setMeteringPoint({x:1,y:1});
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100
+         * @tc.name      : capturesession getExposureBiasRange api
+         * @tc.desc      : capturesession getExposureBiasRange api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let range = mCameraSession.getExposureBiasRange();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100
+         * @tc.name      : capturesession setExposureBias api
+         * @tc.desc      : capturesession setExposureBias api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let range = mCameraSession.getExposureBiasRange();
+                mCameraSession.setExposureBias(range[0]);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100
+         * @tc.name      : capturesession getExposureValue api
+         * @tc.desc      : capturesession getExposureValue api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let value = mCameraSession.getExposureValue();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100
+         * @tc.name      : capturesession isFocusModeSupported api
+         * @tc.desc      : capturesession isFocusModeSupported api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let issupported = mCameraSession.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100
+         * @tc.name      : capturesession getFocusMode api
+         * @tc.desc      : capturesession getFocusMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let focusmode = mCameraSession.getFocusMode();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100
+         * @tc.name      : capturesession setFocusMode api
+         * @tc.desc      : capturesession setFocusMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+            };
+            sleep(1000);
+            releaseInput();
+            sleep(1000);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100
+         * @tc.name      : capturesession setFocusPoint api
+         * @tc.desc      : capturesession setFocusPoint api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setFocusPoint({x:1,y:1});
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100
+         * @tc.name      : capturesession getFocusPoint api
+         * @tc.desc      : capturesession getFocusPoint api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let point = mCameraSession.getFocusPoint();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100
+         * @tc.name      : capturesession getFocalLength api
+         * @tc.desc      : capturesession getFocalLength api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let length = mCameraSession.getFocalLength();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100
+         * @tc.name      : capturesession getZoomRatioRange api
+         * @tc.desc      : capturesession getZoomRatioRange api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let zoomratiorange = mCameraSession.getZoomRatioRange();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100
+         * @tc.name      : capturesession getZoomRatio api
+         * @tc.desc      : capturesession getZoomRatio api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let zoomratio = mCameraSession.getZoomRatio();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100
+         * @tc.name      : capturesession setZoomRatio api
+         * @tc.desc      : capturesession setZoomRatio api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let zoomratiorange = mCameraSession.getZoomRatioRange();
+                mCameraSession.setZoomRatio(zoomratiorange[0]);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100
+         * @tc.name      : capturesession isVideoStabilizationModeSupported api
+         * @tc.desc      : capturesession isVideoStabilizationModeSupported api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let isVSMS = mCameraSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.LOW);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100
+         * @tc.name      : capturesession getActiveVideoStabilizationMode api
+         * @tc.desc      : capturesession getActiveVideoStabilizationMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                let avstmode = mCameraSession.getActiveVideoStabilizationMode();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100
+         * @tc.name      : capturesession setVideoStabilizationMode api
+         * @tc.desc      : capturesession setVideoStabilizationMode api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            try{
+                mCameraSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.LOW);
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                expect(true).assertTrue();
+            };
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100
+         * @tc.name      : PreviewOutput  start api
+         * @tc.desc      : PreviewOutput  start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            mPreviewOutput.start(async (err) => {
+                if (!err) {
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                    expect(true).assertTrue();
+                }
+            })
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200
+         * @tc.name      : PreviewOutput  start api
+         * @tc.desc      : PreviewOutput  start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+
+            await mPreviewOutput.start().then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100
+         * @tc.name      : videooutput  start api
+         * @tc.desc      : videooutput  start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            if (!isEmpty(cameraOutputCap.videoProfiles)) {
+                for (let i = 0; i < cameraOutputCap.videoProfiles.length; i++) {
+                    videoOutput = mCameraManager.createVideoOutput(cameraOutputCap.videoProfiles[i], videoSurfaceId);
+                    if (!isEmpty(videoOutput)) {
+                        break;
+                    }
+                }
+            }
+            mCameraSession.addOutput(mPreviewOutput);
+            if (!isEmpty(videoOutput)) {
+                mCameraSession.addOutput(videoOutput);
+                videoOutput.start(async (err) => {
+                    if (!err) {
+                        console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100 success");
+                    } else {
+                        console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100 FAILED");
+                        console.info(TAG + "ERRORCODE: " + err.code);
+                        expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                        expect(true).assertTrue();
+                    }
+                })
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200
+         * @tc.name      : videooutput  start api
+         * @tc.desc      : videooutput  start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            if (!isEmpty(videoOutput)) {
+                mCameraSession.addOutput(videoOutput);
+                await videoOutput.start().then((result) => {
+                    console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200 success :' + result);
+                }).catch((err) => {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                });
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100
+         * @tc.name      : MetadataOutput start api
+         * @tc.desc      : MetadataOutput start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            if (isEmpty(metadataOutput)) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 metadataOutput IS NULL");
+            } else {
+                mCameraSession.addOutput(metadataOutput);
+                metadataOutput.start(async (err) => {
+                    if (!err) {
+                        console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 success");
+                    } else {
+                        console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 FAILED");
+                        console.info(TAG + "ERRORCODE: " + err.code);
+                        expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                        expect(true).assertTrue();
+                    }
+                })
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200
+         * @tc.name      : metadataOutput  start api
+         * @tc.desc      : metadataOutput  start api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            if (isEmpty(metadataOutput)) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 metadataOutput IS NULL");
+            } else {
+                mCameraSession.addOutput(metadataOutput);
+                await metadataOutput.start().then((result) => {
+                    console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 success :' + result);
+                }).catch((err) => {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue();
+                    expect(true).assertTrue();
+                });
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            await mPhotoOutput.capture().then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue();
+                expect(true).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            mPhotoOutput.capture(async (err) => {
+                if (!err) {
+                    expect(true).assertTrue();
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue();
+                    expect(true).assertTrue();
+                }
+            })
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            mPhotoOutput.capture(captureSetting,async (err) => {
+                if (!err) {
+                    expect(true).assertTrue();
+                    console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700 success");
+                } else {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue();
+                    expect(true).assertTrue();
+                }
+            })
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800
+         * @tc.name      : photoOutput capture api
+         * @tc.desc      : photoOutput capture api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800--------------");
+            await createInput(0);
+            createCameraSessionInstance();
+            mCameraSession.addInput(mCameraInput);
+            createOutput(0);
+            mCameraSession.addOutput(mPreviewOutput);
+            mCameraSession.addOutput(mPhotoOutput);
+            await commitCameraSessionConfig();
+            await mPhotoOutput.capture(captureSetting).then((result) => {
+                console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800 success :' + result);
+            }).catch((err) => {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800 FAILED");
+                console.info(TAG + "ERRORCODE: " + err.code);
+                expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue();
+                expect(true).assertTrue();
+            });
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100
+         * @tc.name      : capturesession beginConfig api
+         * @tc.desc      : capturesession beginConfig api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100--------------");
+            await createInput(0);
+            mCameraSession = mCameraManager.createCaptureSession();
+            mCameraSession.beginConfig();
+            try {
+                mCameraSession.beginConfig();
+            } catch (error) {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100 FAILED");
+                console.info(TAG + "ERRORCODE: " + error.code);
+                expect(error.code == cameraObj.CameraErrorCode.SESSION_CONFIG_LOCKED).assertTrue();
+                expect(true).assertTrue();
+            }
+            sleep(100);
+            releaseInput();
+            sleep(100);
+            releaseCameraSessionInstance();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100
+         * @tc.name      : CameraInput  open api
+         * @tc.desc      : CameraInput  open api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100--------------");
+            mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[0]);
+            if (!isEmpty(mCameraInput)) {
+                mCameraInput.open(async (err) => {
+                    console.info(TAG + "Entering mCameraInput open callback");
+                    if (!err) {
+                        console.info(TAG + "Entering mCameraInput open PASSED ");
+                    } else {
+                        console.info(TAG + "Entering mCameraInput open FAILED : " + err.message);
+                    }
+                })
+                mCameraInput.open(async (err) => {
+                    console.info(TAG + "Entering mCameraInput open callback");
+                    if (!err) {
+                        console.info(TAG + "Entering mCameraInput open PASSED ");
+                    } else {
+                        console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100 FAILED");
+                        console.info(TAG + "ERRORCODE: " + err.code);
+                        expect(err.code == cameraObj.CameraErrorCode.CONFILICT_CAMERA).assertTrue();
+                        expect(true).assertTrue();
+                    }
+                })
+            } else {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100 createCameraInput FAILED");
+            }
+            sleep(100);
+            releaseInput();
+            done();
+        })
+
+        /**
+         * @tc.number    : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200
+         * @tc.name      : CameraInput  open api
+         * @tc.desc      : CameraInput  open api
+         * @tc.size      : MEDIUM
+         * @tc.type      : Function
+         * @tc.level     : Level 0
+        */
+        it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200', 0, async function (done) {
+            console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200--------------");
+            mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[0]);
+            if (!isEmpty(mCameraInput)) {
+                await mCameraInput.open().then((result) => {
+                    console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 success :' + result);
+                }).catch((err) => {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                });
+                await mCameraInput.open().then((result) => {
+                    console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 success :' + result);
+                }).catch((err) => {
+                    console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 FAILED");
+                    console.info(TAG + "ERRORCODE: " + err.code);
+                    expect(err.code == cameraObj.CameraErrorCode.CONFILICT_CAMERA).assertTrue();
+                    expect(true).assertTrue();
+                });
+            } else {
+                console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 createCameraInput FAILED");
+            }
+            sleep(100);
+            releaseInput();
+            done();
+        })
+    })
+}
\ No newline at end of file