Skip to content

X
Xts Acts

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

通知 9
Star 22
Fork 0
X
Xts Acts
提交 e942a662 编写于 作者: W weiyufeng
浏览文件
操作

song : add fileLock xts test 

Signed-off-by: Ncaochuan <caochuan@huawei.com>
上级 4d4e13b5
隐藏空白更改
内联 并排
Showing with 575 addition and 617 deletion
storage/storagefileiov9jstest/src/main/js/test/members/fileLock.test.js
浏览文件 @ e942a662
......@@ -19,650 +19,608 @@ import {
} from '../Common';
export default function fileIOFileLock() {
describe('fileIO_fs_file_lock', function () {
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0000
* @tc.name fileIO_test_filelock_promise_0000
* @tc.desc Test lock() interfaces. argument is : default.
* Open the file, file lock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
describe('fileIO_fs_file_lock', function () {
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0000
* @tc.name fileIO_test_filelock_promise_000
* @tc.desc Test lock() interfaces. argument is : default.
* Open the file, file lock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0000 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0001
* @tc.name fileIO_test_filelock_promise_0001
* @tc.desc Test lock() interfaces. argument is : true.
* Open the file, file lock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(true);
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0001 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0002
* @tc.name fileIO_test_filelock_promise_0002
* @tc.desc Test lock() interfaces. argument is : false.
* Open the file, file lock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(false);
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0002 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0003
* @tc.name fileIO_test_filelock_promise_0003
* @tc.desc Test tryLock() interfaces. argument is : default.
* Open the file, file lock() ,tryLock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0003', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0003');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock();
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0003 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0004
* @tc.name fileIO_test_filelock_promise_0004
* @tc.desc Test tryLock() interfaces. argument is : true.
* Open the file, file lock() ,tryLock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0004', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0004');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(true);
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0004 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0005
* @tc.name fileIO_test_filelock_promise_0005
* @tc.desc Test tryLock() interfaces. argument is : false.
* Open the file, file lock() ,tryLock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0005', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0005');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_000 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0100
* @tc.name fileIO_test_filelock_promise_001
* @tc.desc Test lock() interfaces. argument is : true.
* Open the file, file lock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(false);
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0005 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0006
* @tc.name fileIO_test_filelock_promise_0006
* @tc.desc Open the file, no file lock(), tryLock(), unlock(),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0006', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0006');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(true);
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_001 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0200
* @tc.name fileIO_test_filelock_promise_002
* @tc.desc Test lock() interfaces. argument is : false.
* Open the file, file lock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.tryLock();
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0006 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0007
* @tc.name fileIO_test_filelock_promise_0007
* @tc.desc Open the file, no file lock(), no tryLock(), unlock(),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_0007', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_0007');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(false);
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_002 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0300
* @tc.name fileIO_test_filelock_promise_003
* @tc.desc Test tryLock() interfaces. argument is : default.
* Open the file, file lock() ,tryLock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_003', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_003');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_0007 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0000
* @tc.name fileIO_test_filelock_promise_abnormal_0000
* @tc.desc Test lock() interfaces. argument is : null.
* Open the file, file lock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock();
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_003 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0400
* @tc.name fileIO_test_filelock_promise_004
* @tc.desc Test tryLock() interfaces. argument is : true.
* Open the file, file lock() ,tryLock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_004', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_004');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(null);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0000 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0001
* @tc.name fileIO_test_filelock_promise_abnormal_0001
* @tc.desc Test lock() interfaces. argument is : true, true.
* Open the file, file lock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(true);
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_004 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0500
* @tc.name fileIO_test_filelock_promise_005
* @tc.desc Test tryLock() interfaces. argument is : false.
* Open the file, file lock() ,tryLock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_005', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_005');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(true, true);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0001 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0002
* @tc.name fileIO_test_filelock_promise_abnormal_0002
* @tc.desc Test lock() interfaces. argument is : -1.
* Open the file, file lock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(false);
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_005 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0600
* @tc.name fileIO_test_filelock_promise_006
* @tc.desc Open the file, no file lock(), tryLock(), unlock(),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_006', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_006');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(-1);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0002 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0003
* @tc.name fileIO_test_filelock_promise_abnormal_0003
* @tc.desc Test tryLock() interfaces. argument is : null.
* Open the file, file lock(), tryLock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0003', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0003');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.tryLock();
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_006 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_0700
* @tc.name fileIO_test_filelock_promise_007
* @tc.desc Open the file, no file lock(), no tryLock(), unlock(),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_007', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_007');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(null);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0003 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0004
* @tc.name fileIO_test_filelock_promise_abnormal_0004
* @tc.desc Test tryLock() interfaces. argument is : true, true.
* Open the file, file lock(), tryLock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0004', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0004');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_007 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0800
* @tc.name fileIO_test_filelock_promise_abnormal_000
* @tc.desc Test lock() interfaces. argument is : null.
* Open the file, file lock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(true, true);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0004 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0005
* @tc.name fileIO_test_filelock_promise_abnormal_0005
* @tc.desc Test tryLock() interfaces. argument is : -1.
* Open the file, file lock(), tryLock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0005', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0005');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(null);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_000 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0100
* @tc.name fileIO_test_filelock_promise_abnormal_001
* @tc.desc Test lock() interfaces. argument is : true, true.
* Open the file, file lock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(-1);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0005 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0006
* @tc.name fileIO_test_filelock_promise_abnormal_0006
* @tc.desc Test unlock() interfaces. argument is : true.
* Open the file, file lock(), tryLock(), unlock(true),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_0006', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_0006');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(true, true);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_001 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0200
* @tc.name fileIO_test_filelock_promise_abnormal_002
* @tc.desc Test lock() interfaces. argument is : -1.
* Open the file, file lock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock();
file.unlock(true);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
} catch (e) {
console.log('fileIO_test_filelock_promise_abnormal_0006 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock(-1);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_002 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0300
* @tc.name fileIO_test_filelock_promise_abnormal_003
* @tc.desc Test tryLock() interfaces. argument is : null.
* Open the file, file lock(), tryLock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_003', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_003');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_0000
* @tc.name fileIO_test_filelock_callback_0000
* @tc.desc Test lock() interfaces. argument is : default.
* Open the file, file lock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_0000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_0000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(null);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_003 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0400
* @tc.name fileIO_test_filelock_promise_abnormal_004
* @tc.desc Test tryLock() interfaces. argument is : true, true.
* Open the file, file lock(), tryLock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_004', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_004');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock((err) => {
if (err) {
console.log('fileIO_test_filelock_callback_0000 err ' + JSON.stringify(err));
expect(false).assertTrue();
done();
}
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(true, true);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_004 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_0000 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_0001
* @tc.name fileIO_test_filelock_callback_0001
* @tc.desc Test lock() interfaces. argument is : true.
* Open the file, file lock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_0001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_0001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0500
* @tc.name fileIO_test_filelock_promise_abnormal_005
* @tc.desc Test tryLock() interfaces. argument is : -1.
* Open the file, file lock(), tryLock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_005', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_005');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(true, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_0001 err ' + JSON.stringify(err));
expect(false).assertTrue();
done();
}
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock(-1);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_005 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_0001 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_002
* @tc.name fileIO_test_filelock_callback_0002
* @tc.desc Test lock() interfaces. argument is : false.
* Open the file, file lock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_0002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_0002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0600
* @tc.name fileIO_test_filelock_promise_abnormal_006
* @tc.desc Test unlock() interfaces. argument is : true.
* Open the file, file lock(), tryLock(), unlock(true),
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_promise_abnormal_006', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_promise_abnormal_006');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(false, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_0002 err ' + JSON.stringify(err));
expect(false).assertTrue();
done();
}
file.unlock();
expect(true).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
await file.lock();
file.tryLock();
file.unlock(true);
expect(false).assertTrue();
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_promise_abnormal_006 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_0002 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0000
* @tc.name fileIO_test_filelock_callback_abnormal_0000
* @tc.desc Test lock() interfaces. argument is : null.
* Open the file, file lock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_0000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_0000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_0000
* @tc.name fileIO_test_filelock_callback_000
* @tc.desc Test lock() interfaces. argument is : default.
* Open the file, file lock() and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(null, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_abnormal_0000 err ' + JSON.stringify(err));
expect(err.code == 13900020 && err.message == 'Invalid argument').assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock((err) => {
if (err) {
console.log('fileIO_test_filelock_callback_000 err ' + JSON.stringify(err));
expect(false).assertTrue();
}
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
}
file.unlock();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_000 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_abnormal_0000 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0001
* @tc.name fileIO_test_filelock_callback_abnormal_0001
* @tc.desc Test lock() interfaces. argument is : true, true.
* Open the file, file lock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_0001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_0001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_0100
* @tc.name fileIO_test_filelock_callback_001
* @tc.desc Test lock() interfaces. argument is : true.
* Open the file, file lock(true) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(true, true, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_abnormal_0001 err ' + JSON.stringify(err));
expect(err.code == 13900020 && err.message == 'Invalid argument').assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(true, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_001 err ' + JSON.stringify(err));
expect(false).assertTrue();
}
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
}
file.unlock();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_001 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_abnormal_0001 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0002
* @tc.name fileIO_test_filelock_callback_abnormal_0002
* @tc.desc Test lock() interfaces. argument is : -1.
* Open the file, file lock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_0002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_0002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_0200
* @tc.name fileIO_test_filelock_callback_002
* @tc.desc Test lock() interfaces. argument is : false.
* Open the file, file lock(false) and unlock()
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(-1, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_abnormal_0002 err ' + JSON.stringify(err));
expect(err.code == 13900020 && err.message == 'Invalid argument').assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(false, (err) => {
if (err) {
console.log('fileIO_test_filelock_callback_002 err ' + JSON.stringify(err));
expect(false).assertTrue();
}
file.unlock();
expect(true).assertTrue();
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
done();
}
file.unlock();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_002 has failed for ' + e.message + ', code: ' + e.code);
expect(false).assertTrue();
file.closeSync(file.fd);
file.unlinkSync(fpath);
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0000
* @tc.name fileIO_test_filelock_callback_abnormal_000
* @tc.desc Test lock() interfaces. argument is : null.
* Open the file, file lock(null).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_000', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_000');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(null, (err) => {
expect(false).assertTrue();
});
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_callback_abnormal_000 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0100
* @tc.name fileIO_test_filelock_callback_abnormal_001
* @tc.desc Test lock() interfaces. argument is : true, true.
* Open the file, file lock(true, true).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_001', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_001');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(true, true, (err) => {
expect(false).assertTrue();
});
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_callback_abnormal_001 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
});
/**
* @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0200
* @tc.name fileIO_test_filelock_callback_abnormal_002
* @tc.desc Test lock() interfaces. argument is : -1.
* Open the file, file lock(-1).
* @tc.size MEDIUM
* @tc.type Functoin
* @tc.level Level 0
* @tc.require
*/
it('fileIO_test_filelock_callback_abnormal_002', 0, async function (done) {
let fpath = await nextFileName('fileIO_test_filelock_callback_abnormal_002');
expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
try {
let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
expect(isIntNum(file.fd)).assertTrue();
file.lock(-1, (err) => {
expect(false).assertTrue();
});
} catch (e) {
fileIO.closeSync(file.fd);
fileIO.unlinkSync(fpath);
console.log('fileIO_test_filelock_callback_abnormal_002 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
});
} catch (e) {
console.log('fileIO_test_filelock_callback_abnormal_0002 has failed for ' + e.message + ', code: ' + e.code);
expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
done();
}
}
});
});
});
}
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或