Skip to content

X
Xts Acts

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

通知 9
Star 22
Fork 0
X
Xts Acts
提交 b4e88dec 编写于 作者: Y yangbo
浏览文件
操作

predicates 

Signed-off-by: Nyangbo <yangbo258@h-partners.com>
上级 b7b8f238
展开全部 隐藏空白更改
内联 并排
Showing with 912 addition and 1447 deletion
multimedia/userfilemgr/common.js
浏览文件 @ b4e88dec
......@@ -16,19 +16,18 @@
import userfile_manager from '@ohos.filemanagement.userfile_manager';
import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import bundle from '@ohos.bundle';
import dataSharePredicates from '@ohos.data.dataSharePredicates';
const presetsCount = {
ActsUserFileMgrAlbumJsTest: { albumsCount: 9, assetsCount: 9 },
ActsUserFileMgrBaseJsTest: { albumsCount: 12, assetsCount: 24 },
ActsUserFileMgrFileAssetJsTest: { albumsCount: 45, assetsCount: 116 },
ActsUserFileMgrAlbumJsTest: { albumsCount: 3, assetsCount: 3 },
ActsUserFileMgrBaseJsTest: { albumsCount: 9, assetsCount: 18 },
ActsUserFileMgrFileAssetJsTest: { albumsCount: 45, assetsCount: 87 },
}
const IMAGE_TYPE = userfile_manager.MediaType.IMAGE;
const VIDEO_TYPE = userfile_manager.MediaType.VIDEO;
const AUDIO_TYPE = userfile_manager.MediaType.AUDIO;
const FILE_TYPE = userfile_manager.MediaType.FILE;
const FILEKEY = userfile_manager.FileKey;
const AUDIOKEY = userfile_manager.AudioKey;
const IMAGEVIDEOKEY = userfile_manager.ImageVideoKey;
const ALBUMKEY = userfile_manager.AlbumKey;
......@@ -40,96 +39,86 @@ const sleep = async function sleep(times) {
}
const allFetchOp = function () {
let predicates = new dataSharePredicates.DataSharePredicates();
return {
selections: '',
selectionArgs: [],
predicates: predicates
};
}
const fileFetchOps = function (testNum, path) {
let ops = {
selections: FILEKEY.RELATIVE_PATH + '= ?',
selectionArgs: [path],
};
console.info(`${testNum}: fileFetchOps${JSON.stringify(ops)}`)
return ops
}
const audioFetchOps = function (testNum, path) {
let predicates = new dataSharePredicates.DataSharePredicates();
predicates.equalTo(AUDIOKEY.RELATIVE_PATH, path);
let ops = {
selections: AUDIOKEY.RELATIVE_PATH + '= ?',
selectionArgs: [path],
predicates: predicates
};
console.info(`${testNum}: audioFetchOps${JSON.stringify(ops)}`)
console.info(`${testNum} queryOps: relative_path = ${path}`);
return ops
}
const imageVideoFetchOps = function (testNum, path) {
let predicates = new dataSharePredicates.DataSharePredicates();
predicates.equalTo(IMAGEVIDEOKEY.RELATIVE_PATH, path);
let ops = {
selections: IMAGEVIDEOKEY.RELATIVE_PATH + '= ?',
selectionArgs: [path],
};
console.info(`${testNum}: imageVideoFetchOps${JSON.stringify(ops)}`)
return ops
}
const fileNameFetchOps = function (testNum, path, displayName) {
let ops = {
selections: FILEKEY.RELATIVE_PATH + '= ? AND ' + FILEKEY.DISPLAY_NAME + '= ?',
selectionArgs: [path, displayName],
predicates: predicates
};
console.info(`${testNum}: fileNameFetchOps${JSON.stringify(ops)}`)
console.info(`${testNum} queryOps: relative_path = ${path}`);
return ops
}
const audioNameFetchOps = function (testNum, path, displayName) {
let predicates = new dataSharePredicates.DataSharePredicates();
predicates.equalTo(AUDIOKEY.RELATIVE_PATH, path)
.equalTo(AUDIOKEY.DISPLAY_NAME, displayName);
let ops = {
selections: AUDIOKEY.RELATIVE_PATH + '= ? AND ' + AUDIOKEY.DISPLAY_NAME + '= ?',
selectionArgs: [path, displayName],
predicates: predicates
};
console.info(`${testNum}: audioNameFetchOps${JSON.stringify(ops)}`)
console.info(`${testNum} queryOps: relative_path = ${path} AND display_name = ${displayName}`);
return ops
}
const imageVideoNameFetchOps = function (testNum, path, displayName) {
let predicates = new dataSharePredicates.DataSharePredicates();
predicates.equalTo(IMAGEVIDEOKEY.RELATIVE_PATH, path)
.equalTo(IMAGEVIDEOKEY.DISPLAY_NAME, displayName);
let ops = {
selections: IMAGEVIDEOKEY.RELATIVE_PATH + '= ? AND ' + IMAGEVIDEOKEY.DISPLAY_NAME + '= ?',
selectionArgs: [path, displayName],
predicates: predicates
};
console.info(`${testNum}: imageVideoNameFetchOps${JSON.stringify(ops)}`)
console.info(`${testNum} queryOps: relative_path = ${path} AND display_name = ${displayName}`);
return ops
}
const albumFetchOps = function (testNum, path, albumName) {
let predicates = new dataSharePredicates.DataSharePredicates();
predicates.equalTo(ALBUMKEY.RELATIVE_PATH, path)
.equalTo("bucket_display_name", albumName);
let ops = {
selections: ALBUMKEY.RELATIVE_PATH + '= ? AND ' + 'bucket_display_name' + '= ?',
selectionArgs: [path, albumName],
predicates: predicates
};
console.info(`${testNum}: albumFetchOps${JSON.stringify(ops)}`)
console.info(`${testNum} queryOps: relative_path = ${path} AND bucket_display_name = ${albumName}`);
return ops
}
const checkPresetsAssets = async function (userfilemgr, hapName) {
console.info('checkPresetsAssets start')
let fetchAlbumResult = await userfilemgr.getAlbums([IMAGE_TYPE, VIDEO_TYPE, AUDIO_TYPE], allFetchOp());
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(allFetchOp());
let albumsCount = fetchAlbumResult.getCount();
let fetchFileResult = await userfilemgr.getFileAssets([IMAGE_TYPE, VIDEO_TYPE, AUDIO_TYPE],
allFetchOp());
let assetsCount = await fetchFileResult.getCount();
let fetchPhotoResult = await userfilemgr.getPhotoAssets(allFetchOp());
let fetchAudioResult = await userfilemgr.getAudioAssets(allFetchOp());
let assetsCount = fetchPhotoResult.getCount() + fetchAudioResult.getCount();
console.info(`${hapName}:: assetsCount: ${assetsCount} albumsCount: ${albumsCount},
presetsassetsCount: ${presetsCount[hapName].assetsCount}
presetsalbumsCount: ${presetsCount[hapName].albumsCount}`);
console.info('checkPresetsAssets end')
}
const checkAssetsCount = async function (done, testNum, fetchFileResult, expectCount) {
if (!fetchFileResult) {
console.info(`${testNum}:: fetchFileResult is undefined`);
const checkAssetsCount = async function (done, testNum, fetchAssetResult, expectCount) {
if (!fetchAssetResult) {
console.info(`${testNum}:: fetchAssetResult is undefined`);
expect(false).assertTrue();
done();
return false
}
let count = await fetchFileResult.getCount();
let count = await fetchAssetResult.getCount();
if (count != expectCount) {
console.info(`${testNum}:: count:expectCount - ${count} : ${expectCount}`);
expect(count).assertEqual(expectCount);
......@@ -174,14 +163,10 @@ export {
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILE_TYPE,
FILEKEY,
sleep,
allFetchOp,
fileFetchOps,
audioFetchOps,
imageVideoFetchOps,
fileNameFetchOps,
audioNameFetchOps,
imageVideoNameFetchOps,
albumFetchOps,
......
multimedia/userfilemgr/userfilemgr_album/entry/src/main/ets/test/albumCommitModifyCallback.test.ets
浏览文件 @ b4e88dec
......@@ -18,9 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
albumFetchOps,
checkPresetsAssets,
checkAssetsCount,
......@@ -30,11 +27,11 @@ import {
export default function albumCommitModifyCallback(abilityContext) {
describe('albumCommitModifyCallback', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await getPermission();
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,13 +44,14 @@ export default function albumCommitModifyCallback(abilityContext) {
console.info('afterAll case');
});
const albumCommitModify = async function (done, testNum, media_type, fetchOp, expectAlbumCount) {
const albumCommitModify = async function (done, testNum, fetchOp, expectAlbumCount = 1) {
try {
const fetchAlbumResult = await userfile_mgr.getAlbums(media_type, fetchOp);
const fetchAlbumResult = await userfilemgr.getPhotoAlbums(fetchOp);
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = await fetchAlbumResult.getFirstObject();
const newName = 'albumName' + media_type.toString();
const newName = 'newAlbumNameCallback';
fetchAlbumResult.close();
album.albumName = newName;
album.commitModify(async () => {
expect(true).assertTrue();
......@@ -76,42 +74,8 @@ export default function albumCommitModifyCallback(abilityContext) {
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_01';
let media_type = [IMAGE_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'DynamicCb');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_02
* @tc.name : commitModify
* @tc.desc : image album modify albumname
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_02', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'DynamicCb');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_03
* @tc.name : commitModify
* @tc.desc : image album modify albumname
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_03', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_CALLBACK_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'DynamicCb');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
await albumCommitModify(done, testNum, currentFetchOp);
});
});
}
......
multimedia/userfilemgr/userfilemgr_album/entry/src/main/ets/test/albumCommitModifyPromise.test.ets
浏览文件 @ b4e88dec
......@@ -18,9 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
albumFetchOps,
checkPresetsAssets,
checkAssetsCount,
......@@ -30,11 +27,11 @@ import {
export default function albumCommitModifyPromise(abilityContext) {
describe('albumCommitModifyPromise', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await getPermission();
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,13 +44,14 @@ export default function albumCommitModifyPromise(abilityContext) {
console.info('afterAll case');
});
const albumCommitModify = async function (done, testNum, media_type, fetchOp, expectAlbumCount) {
const albumCommitModify = async function (done, testNum, fetchOp, expectAlbumCount = 1) {
try {
const fetchAlbumResult = await userfile_mgr.getAlbums(media_type, fetchOp);
const fetchAlbumResult = await userfilemgr.getPhotoAlbums(fetchOp);
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = await fetchAlbumResult.getFirstObject();
const newName = 'albumName' + media_type.toString();
const newName = 'newAlbumNamePromise';
fetchAlbumResult.close();
album.albumName = newName;
await album.commitModify();
expect(true).assertTrue();
......@@ -68,49 +66,15 @@ export default function albumCommitModifyPromise(abilityContext) {
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_01
* @tc.name : commitModify
* @tc.desc : image album modify albumname
* @tc.desc : album modify albumname
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_01';
let media_type = [IMAGE_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'DynamicPro');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_02
* @tc.name : commitModify
* @tc.desc : audio album modify albumname
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_02', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'DynamicPro');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_03
* @tc.name : commitModify
* @tc.desc : video album modify albumname
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_03', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_COMMITMODIFY_PROMISE_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'DynamicPro');
let expectAlbumCount = 1;
await albumCommitModify(done, testNum, media_type, currentFetchOp, expectAlbumCount);
await albumCommitModify(done, testNum, currentFetchOp);
});
});
}
......
multimedia/userfilemgr/userfilemgr_album/entry/src/main/ets/test/albumGetFileAssetsCallback.test.ets
浏览文件 @ b4e88dec
......@@ -17,10 +17,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILEKEY,
allFetchOp,
albumFetchOps,
checkPresetsAssets,
......@@ -29,10 +25,10 @@ import {
export default function albumGetFileAssetsCallback(abilityContext) {
describe('albumGetFileAssetsCallback', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -45,22 +41,24 @@ export default function albumGetFileAssetsCallback(abilityContext) {
console.info('afterAll case');
});
const checkAlbumAssetsCount = async function (done, testNum, media_type, fetchOp, expectAssetsCount, expectAlbumCount = 1) {
const checkAlbumAssetsCount = async function (done, testNum, fetchOp, expectAlbumCount = 1, expectAssetsCount = 1) {
try {
const fetchAlbumResult = await userfile_mgr.getAlbums(media_type, fetchOp);
const fetchAlbumResult = await userfilemgr.getPhotoAlbums(fetchOp);
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = await fetchAlbumResult.getFirstObject();
album.getFileAssets(media_type, allFetchOp(), (error, fetchFileResult) => {
fetchAlbumResult.close();
album.getPhotoAssets(allFetchOp(), (error, fetchAssetResult) => {
if (error != undefined) {
console.info(`${testNum} getFileAssets error: ${error}`);
console.info(`${testNum} getPhotoAssets error: ${error}`);
expect(false).assertTrue();
done();
return;
}
console.info(`${testNum}, getCount: ${fetchFileResult.getCount()}
console.info(`${testNum}, getCount: ${fetchAssetResult.getCount()}
expectAssetsCount: ${expectAssetsCount}`);
expect(fetchFileResult.getCount()).assertEqual(expectAssetsCount);
expect(fetchAssetResult.getCount()).assertEqual(expectAssetsCount);
fetchAssetResult.close();
done();
});
} catch (error) {
......@@ -71,51 +69,17 @@ export default function albumGetFileAssetsCallback(abilityContext) {
}
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_01
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in IMAGE_TYPE
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_CALLBACK_01
* @tc.name : getPhotoAssets
* @tc.desc : Album getPhotoAssets
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_01';
let media_type = [IMAGE_TYPE];
it('SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_CALLBACK_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_CALLBACK_01';
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_02
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in AUDIO_TYPE
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_02', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_03
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in VIDEO_TYPE
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_03', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_CALLBACK_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
await checkAlbumAssetsCount(done, testNum, currentFetchOp);
});
});
}
\ No newline at end of file
multimedia/userfilemgr/userfilemgr_album/entry/src/main/ets/test/albumGetFileAssetsPromise.test.ets
浏览文件 @ b4e88dec
......@@ -19,10 +19,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILEKEY,
allFetchOp,
albumFetchOps,
checkPresetsAssets,
......@@ -31,10 +27,10 @@ import {
export default function albumGetFileAssetsPromise(abilityContext) {
describe('albumGetFileAssetsPromise', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,29 +43,24 @@ export default function albumGetFileAssetsPromise(abilityContext) {
console.info('afterAll case');
});
// Exception request
const abnormalFetchOp = {
selections: 'date_added < 0',
selectionArgs: [],
order: 'date_added DESC LIMIT 0,1',
}
const checkAlbumAssetsCount = async function (done, testNum, media_type, fetchOp, expectAssetsCount, expectAlbumCount = 1) {
const checkAlbumAssetsCount = async function (done, testNum, fetchOp, expectAlbumCount = 1, expectAssetsCount = 1) {
try {
const fetchAlbumResult = await userfile_mgr.getAlbums(media_type, fetchOp);
const fetchAlbumResult = await userfilemgr.getPhotoAlbums(fetchOp);
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = await fetchAlbumResult.getFirstObject();
fetchAlbumResult.close();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let fetchFileResult = await album.getFileAssets(media_type, op);
if (fetchFileResult == undefined) {
let fetchAssetResult = await album.getPhotoAssets(op);
if (fetchAssetResult == undefined) {
expect(false).assertTrue();
done();
return;
}
console.info(`${testNum}, getCount: ${fetchFileResult.getCount()}
console.info(`${testNum}, getCount: ${fetchAssetResult.getCount()}
expectAssetsCount: ${expectAssetsCount}`)
expect(fetchFileResult.getCount()).assertEqual(expectAssetsCount);
expect(fetchAssetResult.getCount()).assertEqual(expectAssetsCount);
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum}, error: ${error}`);
......@@ -79,51 +70,17 @@ export default function albumGetFileAssetsPromise(abilityContext) {
}
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_01
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in IMAGE_TYPE
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_PROMISE_01
* @tc.name : getPhotoAssets
* @tc.desc : Album getPhotoAssets
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_01';
let media_type = [IMAGE_TYPE];
it('SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_PROMISE_01', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETPHOTOASSETS_PROMISE_01';
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_02
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in AUDIO_TYPE
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_02', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
});
/**
* @tc.number : SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_03
* @tc.name : getFileAssets
* @tc.desc : Album getFileAssets in VIDEO_TYPE
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_03', 0, async function (done) {
const testNum = 'SUB_USERFILE_MGR_ALBUM_GETFILEASSETS_PROMISE_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'Static');
let assetsCount = 1;
await checkAlbumAssetsCount(done, testNum, media_type, currentFetchOp, assetsCount);
await checkAlbumAssetsCount(done, testNum, currentFetchOp);
});
});
}
\ No newline at end of file
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/getAlbumsCallback.test.ets
浏览文件 @ b4e88dec
......@@ -18,10 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
allFetchOp,
albumFetchOps,
checkPresetsAssets,
checkAssetsCount,
......@@ -32,11 +28,11 @@ import {
export default function getAlbumsCallbackTest(abilityContext) {
describe('getAlbumsCallbackTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await getPermission();
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -60,9 +56,9 @@ export default function getAlbumsCallbackTest(abilityContext) {
}
const props = {
albumName: 'Static',
albumUri: 'datashare:///userfile_mgr/album/',
count: 4
albumName: 'myAlbum',
albumUri: 'datashare:///userfilemgr/album/',
count: 1
}
const checkProps = async function (done, testNum, album, relativePaths) {
printAlbumMessage(testNum, album);
......@@ -87,11 +83,11 @@ export default function getAlbumsCallbackTest(abilityContext) {
expect(album.relativePath).assertEqual(relativePaths);
}
}
const checkAlbumInfo = async function (done, testNum, media_type, fetchOp, relativePaths) {
const checkAlbumInfo = async function (done, testNum, fetchOp, relativePaths) {
try {
userfile_mgr.getAlbums(media_type, fetchOp, async (err, fetchAlbumResult) => {
userfilemgr.getPhotoAlbums(fetchOp, async (err, fetchAlbumResult) => {
if(err) {
console.info(`${testNum} getAlbums err: ${err}`)
console.info(`${testNum} getPhotoAlbums err: ${err}`)
expect(false).assertTrue();
done();
return;
......@@ -99,8 +95,9 @@ export default function getAlbumsCallbackTest(abilityContext) {
let expectAlbumCount = 1;
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = fetchAlbumResult.getFirstObject();
const album = await fetchAlbumResult.getFirstObject();
checkProps(done, testNum, album, relativePaths);
fetchAlbumResult.close();
done();
});
} catch (error) {
......@@ -111,81 +108,18 @@ export default function getAlbumsCallbackTest(abilityContext) {
}
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_CALLBACK_01
* @tc.name : getAlbums
* @tc.desc : Image type getAlbums by relativePath && albumName, print all album info
* @tc.number : SUB_USERFILE_MGR_GETPHOTOALBUMS_CALLBACK_01
* @tc.name : getPhotoAlbums
* @tc.desc : getPhotoAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_CALLBACK_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_CALLBACK_01';
let media_type = [IMAGE_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'Static');
it('SUB_USERFILE_MGR_GETPHOTOALBUMS_CALLBACK_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETPHOTOALBUMS_CALLBACK_01';
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'myAlbum');
let relativePaths = 'Pictures/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_CALLBACK_02
* @tc.name : getAlbums
* @tc.desc : Audio type getAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_CALLBACK_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_CALLBACK_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'Static');
let relativePaths = 'Audios/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_CALLBACK_03
* @tc.name : getAlbums
* @tc.desc : Video type getAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_CALLBACK_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_CALLBACK_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'Static');
let relativePaths = 'Videos/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_CALLBACK_04
* @tc.name : getAlbums
* @tc.desc : getAlbums by abnormal
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_CALLBACK_04', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_CALLBACK_04';
try {
let media_type = [-1];
let currentFetchOp = allFetchOp();
userfile_mgr.getAlbums(media_type, currentFetchOp, async (err, fetchAlbumResult) => {
console.info(`${testNum}, err: ${err}`);
if (err != undefined) {
expect(true).assertTrue();
done();
return;
}
expect(false).assertTrue();
done();
});
} catch (error) {
console.info(`${testNum}, error: ${error}`);
expect(true).assertTrue();
done();
}
await checkAlbumInfo(done, testNum, currentFetchOp, relativePaths);
});
});
}
......
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/getAlbumsPromise.test.ets
浏览文件 @ b4e88dec
......@@ -18,10 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
allFetchOp,
albumFetchOps,
checkPresetsAssets,
checkAssetsCount,
......@@ -29,10 +25,10 @@ import {
export default function getAlbumsPromiseTest(abilityContext) {
describe('getAlbumsPromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -56,9 +52,9 @@ export default function getAlbumsPromiseTest(abilityContext) {
}
const props = {
albumName: 'Static',
albumUri: 'datashare:///userfile_mgr/album/',
count: 4
albumName: 'myAlbum',
albumUri: 'datashare:///userfilemgr/album/',
count: 1
}
const checkProps = async function (done, testNum, album, relativePaths) {
printAlbumMessage(testNum, album);
......@@ -82,13 +78,14 @@ export default function getAlbumsPromiseTest(abilityContext) {
expect(album.relativePath).assertEqual(relativePaths);
}
}
const checkAlbumInfo = async function (done, testNum, media_type, fetchOp, relativePaths, expectAlbumCount = 1) {
const checkAlbumInfo = async function (done, testNum, fetchOp, relativePaths, expectAlbumCount = 1) {
try {
const fetchAlbumResult = await userfile_mgr.getAlbums(media_type, fetchOp);
const fetchAlbumResult = await userfilemgr.getPhotoAlbums(fetchOp);
const albumCountPass = await checkAssetsCount(done, testNum, fetchAlbumResult, expectAlbumCount);
if (!albumCountPass) return;
const album = fetchAlbumResult.getFirstObject();
const album = await fetchAlbumResult.getFirstObject();
checkProps(done, testNum, album, relativePaths);
fetchAlbumResult.close();
done();
} catch (error) {
console.info(`${testNum}, failed: ${error}`);
......@@ -98,80 +95,18 @@ export default function getAlbumsPromiseTest(abilityContext) {
}
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_PROMISE_01
* @tc.name : getAlbums
* @tc.desc : Image type getAlbums by relativePath && albumName, print all album info
* @tc.number : SUB_USERFILE_MGR_GETPHOTOALBUMS_PROMISE_01
* @tc.name : getPhotoAlbums
* @tc.desc : getPhotoAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_PROMISE_01';
let media_type = [IMAGE_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'Static');
it('SUB_USERFILE_MGR_GETPHOTOALBUMS_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETPHOTOALBUMS_PROMISE_01';
let currentFetchOp = albumFetchOps(testNum, 'Pictures/', 'myAlbum');
let relativePaths = 'Pictures/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_PROMISE_02
* @tc.name : getAlbums
* @tc.desc : Image type getAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_PROMISE_02';
let media_type = [AUDIO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Audios/', 'Static');
let relativePaths = 'Audios/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_PROMISE_03
* @tc.name : getAlbums
* @tc.desc : Image type getAlbums by relativePath && albumName, print all album info
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_PROMISE_03';
let media_type = [VIDEO_TYPE];
let currentFetchOp = albumFetchOps(testNum, 'Videos/', 'Static');
let relativePaths = 'Videos/';
await checkAlbumInfo(done, testNum, media_type, currentFetchOp, relativePaths);
});
/**
* @tc.number : SUB_USERFILE_MGR_GETALBUMS_PROMISE_04
* @tc.name : getAlbums
* @tc.desc : getAlbums by abnormal
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_GETALBUMS_PROMISE_04', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_GETALBUMS_PROMISE_04';
try {
let media_type = [-1];
let currentFetchOp = allFetchOp();
try {
await userfile_mgr.getAlbums(media_type, currentFetchOp);
expect(false).assertTrue();
done();
} catch (error) {
console.info(`${testNum}, error1: ${error}`);
expect(true).assertTrue();
done();
}
} catch (error) {
console.info(`${testNum}, error2: ${error}`);
expect(false).assertTrue();
done();
}
await checkAlbumInfo(done, testNum, currentFetchOp, relativePaths);
});
});
}
......
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/getPublicDirectoryCallback.test.ets
浏览文件 @ b4e88dec
......@@ -23,7 +23,7 @@ import {
export default function getPublicDirectoryCallbackTest(abilityContext) {
describe('getPublicDirectoryCallbackTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
});
......@@ -40,7 +40,7 @@ export default function getPublicDirectoryCallbackTest(abilityContext) {
const getetPublicDirectoryTest = async (done, testNum, dir, val) => {
try {
userfile_mgr.getPublicDirectory(dir, async (err, res) => {
userfilemgr.getPublicDirectory(dir, async (err, res) => {
if (err) {
console.info(`${testNum} err : ${err}`)
expect.assertFail();
......
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/getPublicDirectoryPromise.test.ets
浏览文件 @ b4e88dec
......@@ -23,7 +23,7 @@ import {
export default function getPublicDirectoryPromiseTest(abilityContext) {
describe('getPublicDirectoryPromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
});
......@@ -40,7 +40,7 @@ export default function getPublicDirectoryPromiseTest(abilityContext) {
const getetPublicDirectoryTest = async (done, testNum, dir, val) => {
try {
let res = await userfile_mgr.getPublicDirectory(dir);
let res = await userfilemgr.getPublicDirectory(dir);
expect(res).assertEqual(val);
done();
} catch (error) {
......
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/getUserFileMgr.test.ets
浏览文件 @ b4e88dec
......@@ -19,7 +19,7 @@ import { sleep } from '../../../../../../common';
export default function getUserFileMgrTest(abilityContext) {
describe('getUserFileMgrTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
});
......@@ -44,7 +44,7 @@ export default function getUserFileMgrTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_GETUSERFILEMGR_00', 0, async function (done) {
try {
expect(userfile_mgr != undefined).assertTrue();
expect(userfilemgr != undefined).assertTrue();
done();
} catch (error) {
console.info(`SUB_USERFILE_MGR_GETUSERFILEMGR_00 failed, error: ${error}`);
......
multimedia/userfilemgr/userfilemgr_base/entry/src/main/ets/test/onOffReleasePromise.test.ets
浏览文件 @ b4e88dec
......@@ -18,11 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILE_TYPE,
fileFetchOps,
audioFetchOps,
imageVideoFetchOps,
checkPresetsAssets,
......@@ -32,10 +27,10 @@ import {
export default function onOffReleasePromiseTest(abilityContext) {
describe('onOffReleasePromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrAlbumJsTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrAlbumJsTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -48,14 +43,18 @@ export default function onOffReleasePromiseTest(abilityContext) {
console.info('afterAll case');
});
const onTest = async (done, testNum, media_type, fetchOps, type, newName) => {
const onTest = async (done, testNum, fetchOps, type, newName, isAudio) => {
try {
let count = 0;
userfile_mgr.on(type, () => { count++; });
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOps);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
userfilemgr.on(type, () => { count++; });
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOps);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOps);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
asset.displayName = newName;
await asset.commitModify();
await sleep(1000)
......@@ -67,18 +66,22 @@ export default function onOffReleasePromiseTest(abilityContext) {
done();
}
}
const offTest = async (done, testNum, media_type, fetchOps, type, newName) => {
const offTest = async (done, testNum, fetchOps, type, newName, isAudio) => {
try {
let count = 0;
userfile_mgr.on(type, () => {
userfilemgr.on(type, () => {
count++;
});
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOps);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOps);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOps);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
asset.displayName = newName;
userfile_mgr.off(type);
userfilemgr.off(type);
await asset.commitModify();
await sleep(1000)
expect(count).assertEqual(0);
......@@ -100,11 +103,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_ON_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_ON_PROMISE_01';
let media_type = [IMAGE_TYPE];
let currentFetchOps = imageVideoFetchOps(testNum, 'Pictures/On/');
let type = 'imageChange';
let newName = 'imageChange.jpg';
await onTest(done, testNum, media_type, currentFetchOps, type, newName)
let isAudio = false;
await onTest(done, testNum, currentFetchOps, type, newName, isAudio)
});
/**
......@@ -117,11 +120,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_ON_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_ON_PROMISE_02';
let media_type = [AUDIO_TYPE];
let currentFetchOps = audioFetchOps(testNum, 'Audios/On/');
let type = 'audioChange';
let newName = 'audioChange.mp3';
await onTest(done, testNum, media_type, currentFetchOps, type, newName)
let isAudio = true;
await onTest(done, testNum, currentFetchOps, type, newName, isAudio)
});
/**
......@@ -134,28 +137,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_ON_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_ON_PROMISE_03';
let media_type = [VIDEO_TYPE];
let currentFetchOps = imageVideoFetchOps(testNum, 'Videos/On/');
let type = 'videoChange';
let newName = 'videoChange.mp4';
await onTest(done, testNum, media_type, currentFetchOps, type, newName)
});
/**
* @tc.number : SUB_USERFILE_MGR_ON_PROMISE_04
* @tc.name : ON
* @tc.desc : ON file ASSET
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_ON_PROMISE_04', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_ON_PROMISE_04';
let media_type = [FILE_TYPE];
let currentFetchOps = fileFetchOps(testNum, 'Documents/On/');
let type = 'fileChange';
let newName = 'fileChange.dat';
await onTest(done, testNum, media_type, currentFetchOps, type, newName)
let isAudio = false;
await onTest(done, testNum, currentFetchOps, type, newName, isAudio)
});
/**
......@@ -168,11 +154,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_OFF_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_OFF_PROMISE_01';
let media_type = [IMAGE_TYPE];
let currentFetchOps = imageVideoFetchOps(testNum, 'Pictures/Off/');
let type = 'imageChange';
let newName = 'imageChange.jpg';
await offTest(done, testNum,media_type, currentFetchOps, type, newName)
let isAudio = false;
await offTest(done, testNum,currentFetchOps, type, newName, isAudio)
});
/**
......@@ -185,11 +171,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_OFF_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_OFF_PROMISE_02';
let media_type = [AUDIO_TYPE];
let currentFetchOps = audioFetchOps(testNum, 'Audios/Off/');
let type = 'audioChange';
let newName = 'audioChange.mp3';
await offTest(done, testNum,media_type, currentFetchOps, type, newName)
let isAudio = true;
await offTest(done, testNum,currentFetchOps, type, newName, isAudio)
});
/**
......@@ -202,28 +188,11 @@ export default function onOffReleasePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_OFF_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_OFF_PROMISE_03';
let media_type = [VIDEO_TYPE];
let currentFetchOps = imageVideoFetchOps(testNum, 'Videos/Off/');
let type = 'videoChange';
let newName = 'videoChange.mp4';
await offTest(done, testNum,media_type, currentFetchOps, type, newName)
});
/**
* @tc.number : SUB_USERFILE_MGR_OFF_PROMISE_04
* @tc.name : off
* @tc.desc : off file ASSET
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_OFF_PROMISE_04', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_OFF_PROMISE_04';
let media_type = [FILE_TYPE];
let currentFetchOps = fileFetchOps(testNum, 'Documents/Off/');
let type = 'fileChange';
let newName = 'fileChange.dat';
await offTest(done, testNum,media_type, currentFetchOps, type, newName)
let isAudio = false;
await offTest(done, testNum,currentFetchOps, type, newName, isAudio)
});
/**
......@@ -237,7 +206,7 @@ export default function onOffReleasePromiseTest(abilityContext) {
it('SUB_USERFILE_MGR_PROMISE_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_PROMISE_PROMISE_01';
try {
await userfile_mgr.release();
await userfilemgr.release();
expect(true).assertTrue();
done();
} catch (error) {
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetCommitModifyCallback.test.ets
浏览文件 @ b4e88dec
......@@ -30,11 +30,11 @@ import {
export default function fileAssetCommitModifyCallbackTest(abilityContext) {
describe('fileAssetCommitModifyCallbackTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await getPermission();
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,12 +47,15 @@ export default function fileAssetCommitModifyCallbackTest(abilityContext) {
console.info('afterAll case');
});
const checkCommitModify = async function (done, testNum, media_type, fetchOp, prop, val) {
const checkCommitModify = async function (done, testNum, fetchOp, prop, val, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
const oldVal = asset[prop]
asset[prop] = val;
await asset.commitModify(async (err) => {
......@@ -64,7 +67,7 @@ export default function fileAssetCommitModifyCallbackTest(abilityContext) {
}
asset[prop] = oldVal;
await asset.commitModify();
await fetchFileResult.close();
fetchAssetResult.close();
done();
});
} catch (error) {
......@@ -84,11 +87,11 @@ export default function fileAssetCommitModifyCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_01';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/ModifyCb/', '01.jpg');
let prop = 'displayName'
let val = IMAGE_TYPE.toString() + '.jpg'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = IMAGE_TYPE.toString() + '.jpg';
let isAudio = false;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
/**
......@@ -101,11 +104,11 @@ export default function fileAssetCommitModifyCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_02';
let media_type = [AUDIO_TYPE];
let fetchOp = audioNameFetchOps(testNum, 'Audios/ModifyCb/', '01.mp3');
let prop = 'displayName'
let val = AUDIO_TYPE.toString() + '.mp3'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = AUDIO_TYPE.toString() + '.mp3';
let isAudio = true;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
/**
......@@ -118,11 +121,11 @@ export default function fileAssetCommitModifyCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_CALLBACK_03';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/ModifyCb/', '01.mp4');
let prop = 'displayName'
let val = VIDEO_TYPE.toString() + '.mp4'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = VIDEO_TYPE.toString() + '.mp4';
let isAudio = false;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
});
}
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetCommitModifyPromise.test.ets
浏览文件 @ b4e88dec
......@@ -29,10 +29,10 @@ import {
export default function fileAssetCommitModifyPromiseTest(abilityContext) {
describe('fileAssetCommitModifyPromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -45,21 +45,24 @@ export default function fileAssetCommitModifyPromiseTest(abilityContext) {
console.info('afterAll case');
});
const checkCommitModify = async function (done, testNum, media_type, fetchOp, prop, val) {
const checkCommitModify = async function (done, testNum, fetchOp, prop, val, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
const oldVal = asset[prop]
asset[prop] = val;
await asset.commitModify();
asset[prop] = oldVal;
await asset.commitModify();
await fetchFileResult.close();
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum} error : ${error}`)
console.info(`${testNum} error : ${error}`);
expect(false).assertTrue();
done();
}
......@@ -75,11 +78,11 @@ export default function fileAssetCommitModifyPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_01';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/ModifyPro/', '01.jpg');
let prop = 'displayName'
let val = IMAGE_TYPE.toString() + '.jpg'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = IMAGE_TYPE.toString() + '.jpg';
let isAudio = false;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
/**
......@@ -92,11 +95,11 @@ export default function fileAssetCommitModifyPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_02';
let media_type = [AUDIO_TYPE];
let fetchOp = audioNameFetchOps(testNum, 'Audios/ModifyPro/', '01.mp3');
let prop = 'displayName'
let val = AUDIO_TYPE.toString() + '.mp3'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = AUDIO_TYPE.toString() + '.mp3';
let isAudio = true;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
/**
......@@ -109,11 +112,11 @@ export default function fileAssetCommitModifyPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_COMMITMODIFY_PROMISE_03';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/ModifyPro/', '01.mp4');
let prop = 'displayName'
let val = VIDEO_TYPE.toString() + '.mp4'
await checkCommitModify(done, testNum, media_type, fetchOp, prop, val)
let prop = 'displayName';
let val = VIDEO_TYPE.toString() + '.mp4';
let isAudio = false;
await checkCommitModify(done, testNum, fetchOp, prop, val, isAudio);
});
});
}
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetFavoriteCallback.test.ets
浏览文件 @ b4e88dec
......@@ -17,9 +17,6 @@ import userfile_manager from '@ohos.filemanagement.userfile_manager';
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
checkPresetsAssets,
audioNameFetchOps,
imageVideoNameFetchOps,
......@@ -29,11 +26,11 @@ import {
export default function fileAssetFavoriteCallbackTest(abilityContext) {
describe('fileAssetFavoriteCallbackTest', function () {
var userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
var userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await getPermission();
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFavorite');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFavorite');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -46,75 +43,86 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
console.info('afterAll case');
});
const favoriteDefaultState = async function (done, testNum, media_type, fetchOp) {
const favoriteDefaultState = async function (done, testNum, fetchOp, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
asset.isFavorite(async (err, isFavorite) => {
if (err) {
expect(false).assertTrue();
await fetchFileResult.close();
await fetchAssetResult.close();
done();
return;
}
expect(isFavorite).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done()
});
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
}
const favoriteByTrue = async function (done, testNum, media_type, fetchOp) {
const favoriteByTrue = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
let isFavorite = await asset.isFavorite();
console.info(`${testNum} isFavorite: ${isFavorite}`);
asset.favorite(true, async (err) => {
if(err) {
console.info(`${testNum} failed err: ${err}`)
console.info(`${testNum} failed err: ${err}`);
expect(false).assertTrue();
done();
return;
}
let isFavorite = await asset.isFavorite();
expect(isFavorite).assertEqual(true);
await fetchFileResult.close();
fetchAssetResult.close();
done();
});
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
}
const favoriteByFalse = async function (done, testNum, media_type, fetchOp) {
const favoriteByFalse = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
await asset.favorite(true);
asset.favorite(false, async (err) => {
if(err) {
console.info(`${testNum} failed err: ${err}`)
console.info(`${testNum} failed err: ${err}`);
expect(false).assertTrue();
done();
return;
}
let isFavorite = await asset.isFavorite();
expect(isFavorite).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done();
});
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
......@@ -129,10 +137,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_001'
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '01.jpg')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_001';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '01.jpg');
let isAudio = false;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -144,10 +152,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_002'
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '02.jpg')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_002';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '02.jpg');
let isAudio = false;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -159,10 +167,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_003'
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '03.jpg')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_01_003';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavCb/', '03.jpg');
let isAudio = false;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -174,10 +182,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_001'
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '01.mp3')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_001';
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '01.mp3');
let isAudio = true;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -189,10 +197,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_002'
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '02.mp3')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_002';
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '02.mp3');
let isAudio = true;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -204,10 +212,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_003'
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '03.mp3')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_02_003';
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavCb/', '03.mp3');
let isAudio = true;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -219,10 +227,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_001'
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '01.mp4')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_001';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '01.mp4');
let isAudio = false;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -234,10 +242,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_002'
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '02.mp4')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_002';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '02.mp4');
let isAudio = false;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -249,10 +257,10 @@ export default function fileAssetFavoriteCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_003'
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '03.mp4')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_CALLBACK_03_003';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavCb/', '03.mp4');
let isAudio = false;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
});
}
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetFavoritePromise.test.ets
浏览文件 @ b4e88dec
......@@ -17,9 +17,6 @@ import userfile_manager from '@ohos.filemanagement.userfile_manager';
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
checkPresetsAssets,
audioNameFetchOps,
imageVideoNameFetchOps,
......@@ -28,10 +25,10 @@ import {
export default function fileAssetFavoritePromiseTest(abilityContext) {
describe('fileAssetFavoritePromiseTest', function () {
var userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
var userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFavorite');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFavorite');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -44,53 +41,62 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
console.info('afterAll case');
});
const favoriteDefaultState = async function (done, testNum, media_type, fetchOp) {
const favoriteDefaultState = async function (done, testNum, fetchOp, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
let isFavorite = await asset.isFavorite();
expect(isFavorite).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done()
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
}
const favoriteByTrue = async function (done, testNum, media_type, fetchOp) {
const favoriteByTrue = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
await asset.favorite(true);
let isFavorite = await asset.isFavorite();
expect(isFavorite).assertEqual(true);
await fetchFileResult.close();
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
}
const favoriteByFalse = async function (done, testNum, media_type, fetchOp) {
const favoriteByFalse = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
await asset.favorite(true);
await asset.favorite(false);
let isFavorite = await asset.isFavorite();
expect(isFavorite).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
console.info(`${testNum} failed error: ${error}`);
expect(false).assertTrue();
done();
}
......@@ -106,9 +112,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_001';
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '01.jpg')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '01.jpg');
let isAudio = false;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -121,9 +127,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_002';
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '02.jpg')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '02.jpg');
let isAudio = false;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -136,9 +142,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_01_003';
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '03.jpg')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/FavPro/', '03.jpg');
let isAudio = false;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -151,9 +157,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_02_001';
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '01.mp3')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '01.mp3');
let isAudio = true;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -166,9 +172,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_02_002';
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '02.mp3')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '02.mp3');
let isAudio = true;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -181,9 +187,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_003';
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '03.mp3')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/FavPro/', '03.mp3');
let isAudio = true;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -196,9 +202,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_001';
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '01.mp4')
await favoriteDefaultState(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '01.mp4');
let isAudio = false;
await favoriteDefaultState(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -211,9 +217,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_002';
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '02.mp4')
await favoriteByTrue(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '02.mp4');
let isAudio = false;
await favoriteByTrue(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -226,9 +232,9 @@ export default function fileAssetFavoritePromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_FAVORITE_PROMISE_03_003';
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '03.mp4')
await favoriteByFalse(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/FavPro/', '03.mp4');
let isAudio = false;
await favoriteByFalse(done, testNum, currentFetchOp, isAudio);
});
});
}
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetGetThumbnailCallback.test.ets
浏览文件 @ b4e88dec
......@@ -19,9 +19,6 @@ import image from '@ohos.multimedia.image';
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
checkPresetsAssets,
checkAssetsCount,
audioNameFetchOps,
......@@ -30,10 +27,10 @@ import {
export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
describe('fileAssetGetThumbnailCallbackTest', function () {
image.createPixelMap(new ArrayBuffer(4096), { size: { height: 1, width: 2 } }).then((pixelmap) => { });
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrGetThumbnailTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrGetThumbnailTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -46,24 +43,28 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
console.info('afterAll case');
});
async function testGetThumbnail(done, testNum, media_type, dOp, size) {
async function testGetThumbnail(done, testNum, dOp, size, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, dOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(dOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(dOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
if (size == 'default') {
size = { width: 256, height: 256 };
asset.getThumbnail(async (err, pixelmap) => {
console.info(`${testNum}:: err1 :${err}`);
if (err != undefined) {
console.info(`${testNum}:: err1 :${err}`);
expect(false).assertTrue();
done();
return;
}
await pixelmap.getImageInfo((err, info) => {
console.info(`${testNum}:: err2 :${err}`);
if (err != undefined) {
console.info(`${testNum}:: err2 :${err}`);
expect(false).assertTrue();
done();
return;
......@@ -76,15 +77,15 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
})
} else {
asset.getThumbnail(size, async (err, pixelmap) => {
console.info(`${testNum}:: err1 :${err}`);
if (err != undefined) {
console.info(`${testNum}:: err1 :${err}`);
expect(false).assertTrue();
done();
return;
}
await pixelmap.getImageInfo((err, info) => {
console.info(`${testNum}:: err2 :${err}`);
if (err != undefined) {
console.info(`${testNum}:: err2 :${err}`);
expect(false).assertTrue();
done();
return;
......@@ -113,10 +114,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_01_001';
let media_type = [IMAGE_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Pictures/Thumbnail/', '01.jpg');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -129,10 +130,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_01_002';
let media_type = [IMAGE_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Pictures/Thumbnail/', '02.jpg');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -145,10 +146,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_02_001';
let media_type = [AUDIO_TYPE];
let dOp = audioNameFetchOps(testNum, 'Audios/Thumbnail/', '01.mp3');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = true;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -161,10 +162,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_02_002';
let media_type = [AUDIO_TYPE];
let dOp = audioNameFetchOps(testNum, 'Audios/Thumbnail/', '02.mp3');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = true;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -177,10 +178,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_03_001';
let media_type = [VIDEO_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Videos/Thumbnail/', '01.mp4');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -193,10 +194,10 @@ export default function fileAssetGetThumbnailCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_CALLBACK_03_002';
let media_type = [VIDEO_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Videos/Thumbnail/', '02.mp4');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
});
}
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetGetThumbnailPromise.test.ets
浏览文件 @ b4e88dec
......@@ -18,9 +18,6 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import image from '@ohos.multimedia.image';
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
checkPresetsAssets,
checkAssetsCount,
audioNameFetchOps,
......@@ -30,10 +27,10 @@ import {
export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
describe('fileAssetGetThumbnailPromiseTest', function () {
image.createPixelMap(new ArrayBuffer(4096), { size: { height: 1, width: 2 } }).then((pixelmap) => { });
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrGetThumbnailTest');
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrGetThumbnailTest');
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -46,12 +43,16 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
console.info('afterAll case');
});
async function testGetThumbnail(done, testNum, media_type, dOp, size,) {
async function testGetThumbnail(done, testNum, dOp, size, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, dOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(dOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(dOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
console.info(`${testNum}:displayName ${asset.displayName}`)
let pixelmap;
if (size == 'default') {
......@@ -82,10 +83,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_01_001';
let media_type = [IMAGE_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Pictures/Thumbnail/', '01.jpg');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -98,10 +99,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_01_002';
let media_type = [IMAGE_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Pictures/Thumbnail/', '02.jpg');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -114,10 +115,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_02_001';
let media_type = [AUDIO_TYPE];
let dOp = audioNameFetchOps(testNum, 'Audios/Thumbnail/', '01.mp3');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = true;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -130,10 +131,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_02_002';
let media_type = [AUDIO_TYPE];
let dOp = audioNameFetchOps(testNum, 'Audios/Thumbnail/', '02.mp3');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = true;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -146,10 +147,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_03_001';
let media_type = [VIDEO_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Videos/Thumbnail/', '01.mp4');
let size = 'default';
await testGetThumbnail(done, testNum, media_type, dOp, size,);
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
/**
......@@ -162,10 +163,10 @@ export default function fileAssetGetThumbnailPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_GETTHUMBNAIL_PROMISE_03_002';
let media_type = [VIDEO_TYPE];
let dOp = imageVideoNameFetchOps(testNum, 'Videos/Thumbnail/', '02.mp4');
let size = { width: 128, height: 128 };
await testGetThumbnail(done, testNum, media_type, dOp, size)
let isAudio = false;
await testGetThumbnail(done, testNum, dOp, size, isAudio);
});
});
}
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetIsDirectoryCallback.test.ets
浏览文件 @ b4e88dec
......@@ -18,23 +18,17 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILE_TYPE,
checkPresetsAssets,
checkAssetsCount,
fileNameFetchOps,
audioNameFetchOps,
imageVideoNameFetchOps,
} from '../../../../../../common';
export default function fileAssetIsDirectoryCallbackTest(abilityContext) {
describe('fileAssetIsDirectoryCallbackTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,10 +41,14 @@ export default function fileAssetIsDirectoryCallbackTest(abilityContext) {
console.info('afterAll case');
});
const isDirectoryTest = async function (done, testNum, media_type, fetchOp) {
const isDirectoryTest = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
const asset = await fetchFileResult.getFirstObject();
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
const asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
asset.isDirectory((err, isDir) =>{
if (err) {
console.info(`${testNum} err : ${err}`);
......@@ -77,10 +75,10 @@ export default function fileAssetIsDirectoryCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_CALLBACK_01', 0, async function (done) {
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001'
let media_type = [IMAGE_TYPE];
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001';
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/Static/', '01.jpg');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -92,10 +90,10 @@ export default function fileAssetIsDirectoryCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_CALLBACK_02', 0, async function (done) {
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001'
let media_type = [AUDIO_TYPE];
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001';
let fetchOp = audioNameFetchOps(testNum, 'Audios/Static/', '01.mp3');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = true;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -107,25 +105,10 @@ export default function fileAssetIsDirectoryCallbackTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_CALLBACK_03', 0, async function (done) {
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001'
let media_type = [VIDEO_TYPE];
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001';
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/Static/', '01.mp4');
await isDirectoryTest(done, testNum, media_type, fetchOp)
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_CALLBACK_04
* @tc.name : isDirectory
* @tc.desc : file asset isDirectory
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_CALLBACK_04', 0, async function (done) {
let testNum = 'SUB_MEDIA_MEDIALIBRARY_FILEASSET_ISDIRECTORY_CALLBACK_001'
let media_type = [FILE_TYPE];
let fetchOp = fileNameFetchOps(testNum, 'Documents/Static/', '01.dat');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
});
}
......
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetIsDirectoryPromise.test.ets
浏览文件 @ b4e88dec
......@@ -18,23 +18,17 @@ import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
FILE_TYPE,
fileNameFetchOps,
audioNameFetchOps,
imageVideoNameFetchOps,
checkPresetsAssets,
checkAssetsCount,
} from '../../../../../../common';
export default function fileAssetIsDirectoryPromiseTest(abilityContext) {
describe('fileAssetIsDirectoryPromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,15 +41,19 @@ export default function fileAssetIsDirectoryPromiseTest(abilityContext) {
console.info('afterAll case');
});
const isDirectoryTest = async function (done, testNum, media_type, fetchOp) {
const isDirectoryTest = async function (done, testNum, fetchOp, isAudio) {
try {
const fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
const asset = await fetchFileResult.getFirstObject();
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
const asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
const isDir = await asset.isDirectory();
expect(isDir).assertEqual(false);
done();
} catch (error) {
console.info(`${testNum} error : ${error}`)
console.info(`${testNum} error : ${error}`);
expect(false).assertTrue();
done();
}
......@@ -70,10 +68,10 @@ export default function fileAssetIsDirectoryPromiseTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_01'
let media_type = [IMAGE_TYPE];
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_01';
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/Static/', '01.jpg');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -85,10 +83,10 @@ export default function fileAssetIsDirectoryPromiseTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_02'
let media_type = [AUDIO_TYPE];
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_02';
let fetchOp = audioNameFetchOps(testNum, 'Audios/Static/', '01.mp3');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = true;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -100,25 +98,10 @@ export default function fileAssetIsDirectoryPromiseTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_03'
let media_type = [VIDEO_TYPE];
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_03';
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/Static/', '01.mp4');
await isDirectoryTest(done, testNum, media_type, fetchOp)
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_04
* @tc.name : isDirectory
* @tc.desc : file asset isDirectory
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_04', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_ISDIRECTORY_PROMISE_04'
let media_type = [FILE_TYPE];
let fetchOp = fileNameFetchOps(testNum, 'Documents/Static/', '01.dat');
await isDirectoryTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await isDirectoryTest(done, testNum, fetchOp, isAudio);
});
});
}
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetOpenCallback.test.ets
浏览文件 @ b4e88dec
......@@ -17,9 +17,6 @@ import fileio from '@ohos.fileio';
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
import {
sleep,
IMAGE_TYPE,
VIDEO_TYPE,
AUDIO_TYPE,
audioFetchOps,
imageVideoFetchOps,
audioNameFetchOps,
......@@ -30,10 +27,10 @@ import {
} from '../../../../../../common';
export default function fileAssetOpenCallbackTest(abilityContext) {
describe('fileAssetOpenCallbackTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -46,14 +43,18 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
console.info('afterAll case');
});
const rOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const rOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset;
let fd;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
asset.open('r', async (err, fd) => {
if (err) {
console.info(`${testNum} :: err: ${err}`);
......@@ -83,16 +84,20 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
}
}
const wOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const wOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset, asset1;
let fd, fd1;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset1 = await fetchFileResult.getNextObject();
asset = await fetchAssetResult.getFirstObject();
asset1 = await fetchAssetResult.getNextObject();
fetchAssetResult.close();
asset.open('w', async (err, fd) => {
if (err) {
console.info(`${testNum} :: err: ${err}`);
......@@ -125,14 +130,17 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
}
}
const rwOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const rwOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset, asset1;
let fd, fd1;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset = await fetchAssetResult.getFirstObject();
asset.open('rw', async (err, fd) => {
if (err) {
console.info(`${testNum} :: err: ${err}`);
......@@ -144,7 +152,7 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
let buf = new ArrayBuffer(4096);
let res = await fileio.read(fd, buf);
expect(res.bytesRead).assertEqual(assetProps.bytesRead);
asset1 = await fetchFileResult.getNextObject();
asset1 = await fetchAssetResult.getNextObject();
fd1 = await asset1.open('r');
expect(isNum(fd1)).assertTrue();
let buf1 = new ArrayBuffer(4096);
......@@ -155,6 +163,7 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
console.info(`fd1:${fd1},fd:${fd}`)
await asset.close(fd);
await asset1.close(fd1);
fetchAssetResult.close();
done();
});
} catch (error) {
......@@ -166,14 +175,17 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
}
}
const closeTest = async function (done, testNum, media_type, fetchOp) {
const closeTest = async function (done, testNum, fetchOp, isAudio) {
let asset;
let fd;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
fd = await asset.open('r');
expect(isNum(fd)).assertTrue();
asset.close(fd, async (err) => {
......@@ -217,13 +229,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_001';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/R_Cb/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -236,13 +248,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_002';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/W_Cb/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -255,14 +267,14 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_01_003';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/RW_Cb/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -275,13 +287,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_001';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/R_Cb/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -294,13 +306,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_002';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/W_Cb/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -313,14 +325,14 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_02_003';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/RW_Cb/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -333,13 +345,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_001';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/R_Cb/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -352,13 +364,13 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_002';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/W_Cb/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -371,14 +383,14 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_CALLBACK_03_003';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/RW_Cb/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
//------------------------------------------------------------------------------------
......@@ -393,9 +405,9 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_01';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/openClose/', '01.jpg');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await closeTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -408,9 +420,9 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_02';
let media_type = [AUDIO_TYPE];
let fetchOp = audioNameFetchOps(testNum, 'Audios/openClose/', '01.mp3');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = true;
await closeTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -423,9 +435,9 @@ export default function fileAssetOpenCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_CALLBACK_03';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/openClose/', '01.mp4');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await closeTest(done, testNum, fetchOp, isAudio);
});
});
}
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetOpenPromise.test.ets
浏览文件 @ b4e88dec
......@@ -31,10 +31,10 @@ import {
} from '../../../../../../common';
export default function fileAssetOpenPromiseTest(abilityContext) {
describe('fileAssetOpenPromiseTest', function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info('beforeAll case');
await checkPresetsAssets(userfile_mgr, 'ActsUserFileMgrFileAssetJsTest')
await checkPresetsAssets(userfilemgr, 'ActsUserFileMgrFileAssetJsTest')
});
beforeEach(function () {
console.info('beforeEach case');
......@@ -47,14 +47,18 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
console.info('afterAll case');
});
const rOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const rOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset;
let fd;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset = await fetchAssetResult.getFirstObject();
fetchAssetResult.close();
fd = await asset.open('r');
expect(isNum(fd)).assertTrue();
let buf = new ArrayBuffer(4096);
......@@ -77,16 +81,19 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
}
}
const wOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const wOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset, asset1;
let fd, fd1;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset1 = await fetchFileResult.getNextObject();
asset = await fetchAssetResult.getFirstObject();
asset1 = await fetchAssetResult.getNextObject();
fetchAssetResult.close();
fd = await asset.open('w');
expect(isNum(fd)).assertTrue();
......@@ -115,20 +122,23 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
}
}
const rwOpenTest = async function (done, testNum, media_type, fetchOp, assetProps, expectCount) {
const rwOpenTest = async function (done, testNum, fetchOp, assetProps, expectCount, isAudio) {
let asset, asset1;
let fd, fd1;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, expectCount);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, expectCount);
if (!checkAssetCountPass) return;
asset = await fetchFileResult.getFirstObject();
asset = await fetchAssetResult.getFirstObject();
fd = await asset.open('rw');
expect(isNum(fd)).assertTrue();
let buf = new ArrayBuffer(4096);
let res = await fileio.read(fd, buf);
expect(res.bytesRead).assertEqual(assetProps.bytesRead);
asset1 = await fetchFileResult.getNextObject();
asset1 = await fetchAssetResult.getNextObject();
fd1 = await asset1.open('r');
expect(isNum(fd1)).assertTrue();
let buf1 = new ArrayBuffer(4096);
......@@ -139,6 +149,7 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
console.info(`fd1:${fd1},fd:${fd}`)
await asset.close(fd);
await asset1.close(fd1);
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum} :: error: ${error}`);
......@@ -149,14 +160,17 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
}
}
const closeTest = async function (done, testNum, media_type, fetchOp) {
const closeTest = async function (done, testNum, fetchOp, isAudio) {
let asset;
let fd;
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
const asset = await fetchFileResult.getFirstObject();
const asset = await fetchAssetResult.getFirstObject();
fd = await asset.open('r');
expect(isNum(fd)).assertTrue();
await asset.close(fd);
......@@ -193,13 +207,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_001';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/R_Pro/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -212,13 +226,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_002';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/W_Pro/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -231,14 +245,14 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_01_003';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Pictures/RW_Pro/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -251,13 +265,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_001';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/R_Pro/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -270,13 +284,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_002';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/W_Pro/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -289,14 +303,14 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_02_003';
let media_type = [AUDIO_TYPE];
let fetchOp = audioFetchOps(testNum, 'Audios/RW_Pro/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = true;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -309,13 +323,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_001';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/R_Pro/');
let assetProps = {
bytesRead: 4096,
};
let expectCount = 1;
await rOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -328,13 +342,13 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_002';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/W_Pro/');
let assetProps = {
write: 4096,
};
let expectCount = 2;
await wOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await wOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
/**
......@@ -347,14 +361,14 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_OPEN_PROMISE_03_003';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoFetchOps(testNum, 'Videos/RW_Pro/');
let assetProps = {
bytesRead: 4096,
write: 4096,
};
let expectCount = 2;
await rwOpenTest(done, testNum, media_type, fetchOp, assetProps, expectCount)
let isAudio = false;
await rwOpenTest(done, testNum, fetchOp, assetProps, expectCount, isAudio);
});
//--------------------------------------------------------------------------------
......@@ -369,9 +383,9 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_01', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_01';
let media_type = [IMAGE_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Pictures/openClose/', '02.jpg');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await closeTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -384,9 +398,9 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_02', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_03';
let media_type = [AUDIO_TYPE];
let fetchOp = audioNameFetchOps(testNum, 'Audios/openClose/', '02.mp3');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = true;
await closeTest(done, testNum, fetchOp, isAudio);
});
/**
......@@ -399,9 +413,9 @@ export default function fileAssetOpenPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_03', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_CLOSE_PROMISE_03';
let media_type = [VIDEO_TYPE];
let fetchOp = imageVideoNameFetchOps(testNum, 'Videos/openClose/', '02.mp4');
await closeTest(done, testNum, media_type, fetchOp)
let isAudio = false;
await closeTest(done, testNum, fetchOp, isAudio);
});
});
}
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetTrashCallback.test.ets
浏览文件 @ b4e88dec
......@@ -17,12 +17,7 @@ import userfile_manager from '@ohos.filemanagement.userfile_manager';
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "deccjsunit/index";
import {
sleep,
IMAGE_TYPE,
AUDIO_TYPE,
VIDEO_TYPE,
FILE_TYPE,
allFetchOp,
fileNameFetchOps,
audioNameFetchOps,
imageVideoNameFetchOps,
albumFetchOps,
......@@ -31,7 +26,7 @@ import {
export default function fileAssetTrashCallbackTest(abilityContext) {
describe("fileAssetTrashCallbackTest", function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info("beforeAll case");
});
......@@ -46,21 +41,24 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
console.info("afterAll case");
});
const isTrashTest = async function (done, testNum, media_type, fetchOp) {
const isTrashTest = async function (done, testNum, fetchOp, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
asset.isTrash(async (err, isTrash) => {
if (err) {
expect(false).assertTrue();
await fetchFileResult.close();
await fetchAssetResult.close();
done();
return;
}
expect(isTrash).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done()
});
} catch (error) {
......@@ -70,22 +68,29 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
}
}
async function setTrash(done, testNum, media_type, databasefFetchOps, ablumFetchOps, noAlbum, expectAssetNum = 3) {
async function setTrash(done, testNum, databasefFetchOps, ablumFetchOps, noAlbum, isAudio) {
let expectAssetNum = 3
try {
// database info
let databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
let databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let count = databaseFetchFileResult.getCount();
//album info
if (!noAlbum) {
let fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
let album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let albumFetchFileResult = await album.getFileAssets(media_type, op);
let albumFetchFileResult = await album.getPhotoAssets(op);
let albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum);
fetchAlbumResult.close();
}
// file info
let asset = await databaseFetchFileResult.getFirstObject();
let istrash = await asset.isTrash();
console.info(`${testNum} istrash: ${istrash}`);
// trash operation
asset.trash(true, async (err) => {
if (err) {
......@@ -104,18 +109,23 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
expect(trashState).assertTrue();
try {
// after trash database info
databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let databaseCount = databaseFetchFileResult.getCount();
databaseFetchFileResult.close();
expect(databaseCount).assertEqual(count - 1);
//album info
if (!noAlbum) {
let fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
let album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let albumFetchFileResult = await album.getFileAssets(media_type, op);
let albumFetchFileResult = await album.getPhotoAssets(op);
let albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum - 1);
fetchAlbumResult.close();
}
await asset.trash(false);
done();
......@@ -133,9 +143,13 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
}
}
async function recovery(done, testNum, media_type, databasefFetchOps, ablumFetchOps, noAlbum, expectAssetNum = 3) {
async function recovery(done, testNum, databasefFetchOps, ablumFetchOps, noAlbum, isAudio) {
let expectAssetNum = 3;
try {
let databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
let databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let count = databaseFetchFileResult.getCount();
let asset = await databaseFetchFileResult.getFirstObject();
await asset.trash(true);
......@@ -155,17 +169,22 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
}
expect(trashState).assertFalse();
try {
databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let databaseCount = databaseFetchFileResult.getCount();
databaseFetchFileResult.close();
expect(databaseCount).assertEqual(count);
//album info
if (!noAlbum) {
let fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
let album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let albumFetchFileResult = await album.getFileAssets(media_type, op);
let albumFetchFileResult = await album.getPhotoAssets(op);
let albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum);
fetchAlbumResult.close();
}
done();
} catch (error) {
......@@ -192,9 +211,9 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_001'
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/trashCb/', '01.jpg')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/trashCb/', '01.jpg');
let isAudio = false;
await isTrashTest(done, testNum, currentFetchOp, isAudio)
});
/**
......@@ -207,11 +226,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_002'
let media_type = [IMAGE_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Pictures/trashCb/", '02.jpg');
let aOps = albumFetchOps(testNum, "Pictures/", "trashCb");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -224,11 +243,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_01_003'
let media_type = [IMAGE_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Pictures/trashCb/", '03.jpg');
let aOps = albumFetchOps(testNum, "Pictures/", "trashCb");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -241,9 +260,9 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_001'
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/trashCb/', '01.mp3')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/trashCb/', '01.mp3');
let isAudio = true;
await isTrashTest(done, testNum, currentFetchOp, isAudio)
});
/**
......@@ -256,11 +275,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_002'
let media_type = [AUDIO_TYPE];
let rOps = audioNameFetchOps(testNum, "Audios/trashCb/", '02.mp3');
let aOps = albumFetchOps(testNum, "Audios/", "trashCb");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let noAlbum = true;
let isAudio = true;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -273,11 +292,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_02_003'
let media_type = [AUDIO_TYPE];
let rOps = audioNameFetchOps(testNum, "Audios/trashCb/", '03.mp3');
let aOps = albumFetchOps(testNum, "Audios/", "trashCb");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let noAlbum = true;
let isAudio = true;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -290,9 +309,9 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_001'
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/trashCb/', '01.mp4')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/trashCb/', '01.mp4');
let isAudio = false;
await isTrashTest(done, testNum, currentFetchOp, isAudio)
});
/**
......@@ -305,11 +324,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_002'
let media_type = [VIDEO_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Videos/trashCb/", '02.mp4');
let aOps = albumFetchOps(testNum, "Videos/", "trashCb");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let noAlbum = true;
let isAudio = false;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -322,60 +341,11 @@ export default function fileAssetTrashCallbackTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_03_003'
let media_type = [VIDEO_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Videos/trashCb/", '03.mp4');
let aOps = albumFetchOps(testNum, "Videos/", "trashCb");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_001
* @tc.name : isTrash
* @tc.desc : isTrash(file) result false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_001'
let media_type = [FILE_TYPE];
let currentFetchOp = fileNameFetchOps(testNum, 'Documents/trashCb/', '01.dat')
await isTrashTest(done, testNum, media_type, currentFetchOp)
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_002
* @tc.name : trash
* @tc.desc : trash(file) by true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_002'
let media_type = [FILE_TYPE];
let rOps = fileNameFetchOps(testNum, "Documents/trashCb/", '02.dat');
let aOps = albumFetchOps(testNum, "Documents/", "trashCb");
let noAlbum = true;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_003
* @tc.name : trash
* @tc.desc : trash(file) by false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_CALLBACK_04_003'
let media_type = [FILE_TYPE];
let rOps = fileNameFetchOps(testNum, "Documents/trashCb/", '03.dat');
let aOps = albumFetchOps(testNum, "Documents/", "trashCb");
let noAlbum = true;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
});
}
\ No newline at end of file
multimedia/userfilemgr/userfilemgr_fileAsset/entry/src/main/ets/test/fileAssetTrashPromise.test.ets
浏览文件 @ b4e88dec
......@@ -17,12 +17,7 @@ import userfile_manager from '@ohos.filemanagement.userfile_manager';
import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "deccjsunit/index";
import {
sleep,
IMAGE_TYPE,
AUDIO_TYPE,
VIDEO_TYPE,
FILE_TYPE,
allFetchOp,
fileNameFetchOps,
audioNameFetchOps,
imageVideoNameFetchOps,
albumFetchOps,
......@@ -31,7 +26,7 @@ import {
export default function fileAssetTrashPromiseTest(abilityContext) {
describe("fileAssetTrashPromiseTest", function () {
const userfile_mgr = userfile_manager.getUserFileMgr(abilityContext);
const userfilemgr = userfile_manager.getUserFileMgr(abilityContext);
beforeAll(async function () {
console.info("beforeAll case");
});
......@@ -46,15 +41,18 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
console.info("afterAll case");
});
const isTrashTest = async function (done, testNum, media_type, fetchOp) {
const isTrashTest = async function (done, testNum, fetchOp, isAudio) {
try {
let fetchFileResult = await userfile_mgr.getFileAssets(media_type, fetchOp);
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchFileResult, 1);
let fetchAssetResult = await userfilemgr.getPhotoAssets(fetchOp);
if (isAudio) {
fetchAssetResult = await userfilemgr.getAudioAssets(fetchOp);
}
let checkAssetCountPass = await checkAssetsCount(done, testNum, fetchAssetResult, 1);
if (!checkAssetCountPass) return;
let asset = await fetchFileResult.getFirstObject();
let asset = await fetchAssetResult.getFirstObject();
let isTrash = await asset.isTrash();
expect(isTrash).assertEqual(false);
await fetchFileResult.close();
fetchAssetResult.close();
done();
} catch (error) {
console.info(`${testNum} failed error: ${error}`)
......@@ -63,19 +61,24 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
}
}
async function setTrash(done, testNum, media_type, databasefFetchOps, ablumFetchOps, noAlbum, expectAssetNum = 3) {
async function setTrash(done, testNum, databasefFetchOps, ablumFetchOps, noAlbum, isAudio) {
let expectAssetNum = 3
try {
// database info
let databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
let databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let count = databaseFetchFileResult.getCount();
//album info
if (!noAlbum) {
let fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
let album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let albumFetchFileResult = await album.getFileAssets(media_type, op);
let albumFetchFileResult = await album.getPhotoAssets(op);
let albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum);
fetchAlbumResult.close();
}
// file info
let asset = await databaseFetchFileResult.getFirstObject();
......@@ -83,17 +86,22 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
await asset.trash(true);
let istrash = await asset.isTrash();
console.info(`${testNum} istrash: ${istrash}`);
databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let databaseCount = databaseFetchFileResult.getCount();
databaseFetchFileResult.close()
expect(databaseCount).assertEqual(count - 1);
//album info
if (!noAlbum) {
var fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
var fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
var album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
var albumFetchFileResult = await album.getFileAssets(media_type, op);
var albumFetchFileResult = await album.getPhotoAssets(op);
var albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum - 1);
fetchAlbumResult.close();
}
await asset.trash(false);
done();
......@@ -104,24 +112,33 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
}
}
async function recovery(done, testNum, media_type, databasefFetchOps, ablumFetchOps, noAlbum, expectAssetNum = 3) {
async function recovery(done, testNum, databasefFetchOps, ablumFetchOps, noAlbum, isAudio) {
let expectAssetNum = 3;
try {
let databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
let databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let count = databaseFetchFileResult.getCount();
let asset = await databaseFetchFileResult.getFirstObject();
await asset.trash(true);
await asset.trash(false);
databaseFetchFileResult = await userfile_mgr.getFileAssets(media_type, databasefFetchOps);
databaseFetchFileResult = await userfilemgr.getPhotoAssets(databasefFetchOps);
if (isAudio) {
databaseFetchFileResult = await userfilemgr.getAudioAssets(databasefFetchOps);
}
let databaseCount = databaseFetchFileResult.getCount();
databaseFetchFileResult.close();
expect(databaseCount).assertEqual(count);
//album info
if (!noAlbum) {
let fetchAlbumResult = await userfile_mgr.getAlbums(media_type, ablumFetchOps);
let fetchAlbumResult = await userfilemgr.getPhotoAlbums(ablumFetchOps);
let album = await fetchAlbumResult.getFirstObject();
let op: userfile_manager.MediaFetchOptions = allFetchOp();
let albumFetchFileResult = await album.getFileAssets(media_type, op);
let albumFetchFileResult = await album.getPhotoAssets(op);
let albumFilesCount = albumFetchFileResult.getCount();
expect(albumFilesCount).assertEqual(expectAssetNum);
fetchAlbumResult.close();
}
done();
} catch (error) {
......@@ -140,10 +157,10 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_001'
let media_type = [IMAGE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/trashPro/', '01.jpg')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_001';
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Pictures/trashPro/', '01.jpg');
let isAudio = false;
await isTrashTest(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -155,12 +172,12 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_002'
let media_type = [IMAGE_TYPE];
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_002';
let rOps = imageVideoNameFetchOps(testNum, "Pictures/trashPro/", '02.jpg');
let aOps = albumFetchOps(testNum, "Pictures/", "trashPro");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -173,11 +190,11 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_01_003'
let media_type = [IMAGE_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Pictures/trashPro/", '03.jpg');
let aOps = albumFetchOps(testNum, "Pictures/", "trashPro");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -190,9 +207,9 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_001'
let media_type = [AUDIO_TYPE];
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/trashPro/', '01.mp3')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let currentFetchOp = audioNameFetchOps(testNum, 'Audios/trashPro/', '01.mp3');
let isAudio = true;
await isTrashTest(done, testNum, currentFetchOp, isAudio)
});
/**
......@@ -205,11 +222,11 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_002'
let media_type = [AUDIO_TYPE];
let rOps = audioNameFetchOps(testNum, "Audios/trashPro/", '02.mp3');
let aOps = albumFetchOps(testNum, "Audios/", "trashPro");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let noAlbum = true;
let isAudio = true;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -222,11 +239,11 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_02_003'
let media_type = [AUDIO_TYPE];
let rOps = audioNameFetchOps(testNum, "Audios/trashPro/", '03.mp3');
let aOps = albumFetchOps(testNum, "Audios/", "trashPro");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let noAlbum = true;
let isAudio = true;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -239,9 +256,9 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_001'
let media_type = [VIDEO_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/trashPro/', '01.mp4')
await isTrashTest(done, testNum, media_type, currentFetchOp)
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Videos/trashPro/', '01.mp4');
let isAudio = false;
await isTrashTest(done, testNum, currentFetchOp, isAudio);
});
/**
......@@ -254,11 +271,11 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_002'
let media_type = [VIDEO_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Videos/trashPro/", '02.mp4');
let aOps = albumFetchOps(testNum, "Videos/", "trashPro");
let noAlbum = false;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await setTrash(done, testNum, rOps, aOps, noAlbum, isAudio);
});
/**
......@@ -271,60 +288,11 @@ export default function fileAssetTrashPromiseTest(abilityContext) {
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_03_003'
let media_type = [VIDEO_TYPE];
let rOps = imageVideoNameFetchOps(testNum, "Videos/trashPro/", '03.mp4');
let aOps = albumFetchOps(testNum, "Videos/", "trashPro");
let noAlbum = false;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_001
* @tc.name : isTrash
* @tc.desc : isTrash(file) result false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_001', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_001'
let media_type = [FILE_TYPE];
let currentFetchOp = imageVideoNameFetchOps(testNum, 'Documents/trashPro/', '01.dat')
await isTrashTest(done, testNum, media_type, currentFetchOp)
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_002
* @tc.name : trash
* @tc.desc : trash(file) by true
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_002', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_002'
let media_type = [FILE_TYPE];
let rOps = fileNameFetchOps(testNum, "Documents/trashPro/", '02.dat');
let aOps = albumFetchOps(testNum, "Documents/", "trashPro");
let noAlbum = true;
await setTrash(done, testNum, media_type, rOps, aOps, noAlbum);
});
/**
* @tc.number : SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_003
* @tc.name : trash
* @tc.desc : trash(file) by false
* @tc.size : MEDIUM
* @tc.type : Function
* @tc.level : Level 0
*/
it('SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_003', 0, async function (done) {
let testNum = 'SUB_USERFILE_MGR_FILEASSET_TRASH_PROMISE_04_003'
let media_type = [FILE_TYPE];
let rOps = fileNameFetchOps(testNum, "Documents/trashPro/", '03.dat');
let aOps = albumFetchOps(testNum, "Documents/", "trashPro");
let noAlbum = true;
await recovery(done, testNum, media_type, rOps, aOps, noAlbum);
let isAudio = false;
await recovery(done, testNum, rOps, aOps, noAlbum, isAudio);
});
});
}
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或