Add XTS for option = undefined

Signed-off-by: Nfengjunqing <fengjunqing@huawei.com>

storage/storagefileiov9jstest/src/main/js/test/class_stream/read.test.js

@@ -37,8 +37,10 @@ describe('fileIO_fs_stream_read', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      let readLen = sr.readSync(new ArrayBuffer(4096));
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      let readLen1 = sr.readSync(new ArrayBuffer(16));
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = sr.readSync(new ArrayBuffer(8));
+      expect(readLen2 == 0).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -214,6 +216,70 @@ describe('fileIO_fs_stream_read', function () {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_SYNC_0700
+   * @tc.name fileIO_test_stream_read_sync_007
+   * @tc.desc Test the readSync() interface of class Stream.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_sync_007', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_stream_read_sync_007');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let readLen1 = sr.readSync(new ArrayBuffer(16), undefined);
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = sr.readSync(new ArrayBuffer(8), undefined);
+      expect(readLen2 == 0).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_stream_read_sync_007 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_SYNC_0800
+   * @tc.name fileIO_test_stream_read_sync_008
+   * @tc.desc Test the readSync() interface of class Stream.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_sync_008', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_stream_read_sync_008');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let readLen1 = sr.readSync(new ArrayBuffer(16), {
+        offset: undefined,
+        length: undefined
+      });
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = sr.readSync(new ArrayBuffer(8), {
+        offset: undefined,
+        length: undefined
+      });
+      expect(readLen2 == 0).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_stream_read_sync_008 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_STREAM_READ_ASYNC_0000
    * @tc.name fileIO_test_stream_read_async_000
@@ -231,8 +297,10 @@ describe('fileIO_fs_stream_read', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      let readLen = await sr.read(new ArrayBuffer(4096));
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      let readLen1 = await sr.read(new ArrayBuffer(16));
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await sr.read(new ArrayBuffer(8));
+      expect(readLen2 == 0).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -259,15 +327,22 @@ describe('fileIO_fs_stream_read', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      sr.read(new ArrayBuffer(4096), (err, readLen) => {
+      sr.read(new ArrayBuffer(16), (err, readLen1) => {
         if (err) {
-          console.log('fileIO_test_stream_read_async_001 error package: ' + JSON.stringify(err));
+          console.log('fileIO_test_stream_read_async_001 error package1: ' + JSON.stringify(err));
           expect(false).assertTrue();
         }
-        expect(readLen == FILE_CONTENT.length).assertTrue();
-        sr.closeSync();
-        fileIO.unlinkSync(fpath);
-        done();
+        expect(readLen1 == FILE_CONTENT.length).assertTrue();
+        sr.read(new ArrayBuffer(8), (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_stream_read_async_001 error package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
       });
     } catch (e) {
       console.log('fileIO_test_stream_read_async_001 has failed for ' + e.message + ', code: ' + e.code);
@@ -678,5 +753,157 @@ describe('fileIO_fs_stream_read', function () {
       done();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_ASYNC_1500
+   * @tc.name fileIO_test_stream_read_async_015
+   * @tc.desc Test the read() interface of class Stream. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_async_015', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_read_async_015');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let readLen1 = await sr.read(new ArrayBuffer(16), undefined);
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await sr.read(new ArrayBuffer(8), undefined);
+      expect(readLen2 == 0).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_stream_read_async_015 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_ASYNC_1600
+   * @tc.name fileIO_test_stream_read_async_016
+   * @tc.desc Test the read() interface of class Stream. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_async_016', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_read_async_016');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      sr.read(new ArrayBuffer(16), undefined, (err, readLen1) => {
+        if (err) {
+          console.log('fileIO_test_stream_read_async_016 error package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(readLen1 == FILE_CONTENT.length).assertTrue();
+        sr.read(new ArrayBuffer(8), undefined, (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_stream_read_async_016 error package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_stream_read_async_016 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_ASYNC_1700
+   * @tc.name fileIO_test_stream_read_async_017
+   * @tc.desc Test the read() interface of class Stream. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_async_017', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_read_async_017');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let readLen1 = await sr.read(new ArrayBuffer(16), {
+        offset: undefined,
+        length: undefined
+      });
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await sr.read(new ArrayBuffer(8), {
+        offset: undefined,
+        length: undefined
+      });
+      expect(readLen2 == 0).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_stream_read_async_017 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_READ_ASYNC_1800
+   * @tc.name fileIO_test_stream_read_async_018
+   * @tc.desc Test the read() interface of class Stream. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_read_async_018', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_read_async_018');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      sr.read(new ArrayBuffer(4096), {
+        offset: undefined,
+        length: undefined
+      }, (err, readLen1) => {
+        if (err) {
+          console.log('fileIO_test_stream_read_async_018 error package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(readLen1 == FILE_CONTENT.length).assertTrue();
+        sr.read(new ArrayBuffer(8), {
+          offset: undefined,
+          length: undefined
+        }, (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_stream_read_async_018 error package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_stream_read_async_018 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/class_stream/write.test.js

@@ -37,8 +37,12 @@ describe('fileIO_fs_stream_write', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      let bytesWritten = sr.writeSync(new ArrayBuffer(4096));
-      expect(bytesWritten == 4096).assertTrue();
+      let bytesWritten1 = sr.writeSync(FILE_CONTENT);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = sr.writeSync(new ArrayBuffer(FILE_CONTENT.length));
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -355,6 +359,64 @@ describe('fileIO_fs_stream_write', function () {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_SYNC_1200
+   * @tc.name fileIO_test_stream_write_sync_012
+   * @tc.desc Test the writeSync() interface of class Stream.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_sync_012', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_stream_write_sync_012');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let bytesWritten = sr.writeSync(new ArrayBuffer(4096), undefined);
+      expect(bytesWritten == 4096).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_stream_write_sync_012 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_SYNC_1300
+   * @tc.name fileIO_test_stream_write_sync_013
+   * @tc.desc Test the writeSync() interface of class Stream.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_sync_013', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_stream_write_sync_013');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let bytesWritten = sr.writeSync(new ArrayBuffer(4096), {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      });
+      expect(bytesWritten == 4096).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_stream_write_sync_013 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_STREAM_WRITE_ASYNC_0000
    * @tc.name fileIO_test_stream_write_async_000
@@ -372,8 +434,12 @@ describe('fileIO_fs_stream_write', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      let bytesWritten = await sr.write(new ArrayBuffer(4096));
-      expect(bytesWritten == 4096).assertTrue();
+      let bytesWritten1 = await sr.write(FILE_CONTENT);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await sr.write(new ArrayBuffer(FILE_CONTENT.length));
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -400,15 +466,24 @@ describe('fileIO_fs_stream_write', function () {
     try {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
-      sr.write(new ArrayBuffer(4096), (err, bytesWritten) => {
+      sr.write(FILE_CONTENT, (err, bytesWritten1) => {
         if (err) {
-          console.log('fileIO_test_stream_write_async_001 err package: ' + JSON.stringify(err));
+          console.log('fileIO_test_stream_write_async_001 err package1: ' + JSON.stringify(err));
           expect(false).assertTrue();
         }
-        expect(bytesWritten == 4096).assertTrue();
-        sr.closeSync();
-        fileIO.unlinkSync(fpath);
-        done();
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        sr.write(new ArrayBuffer(FILE_CONTENT.length), (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_stream_write_async_001 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
       });
     } catch (e) {
       console.log('fileIO_test_stream_write_async_001 has failed for ' + e.message + ', code: ' + e.code);
@@ -990,5 +1065,169 @@ describe('fileIO_fs_stream_write', function () {
       done();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_ASYNC_2000
+   * @tc.name fileIO_test_stream_write_async_020
+   * @tc.desc Test the write() interface of class Stream. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_async_020', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_write_async_020');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let bytesWritten1 = await sr.write(FILE_CONTENT, undefined);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await sr.write(new ArrayBuffer(FILE_CONTENT.length), undefined);
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_stream_write_async_020 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_ASYNC_2100
+   * @tc.name fileIO_test_stream_write_async_021
+   * @tc.desc Test the write() interface of class Stream. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_async_021', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_write_async_021');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      sr.write(FILE_CONTENT, undefined, (err, bytesWritten1) => {
+        if (err) {
+          console.log('fileIO_test_stream_write_async_021 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        sr.write(new ArrayBuffer(FILE_CONTENT.length), undefined, (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_stream_write_async_021 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_stream_write_async_021 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_ASYNC_2200
+   * @tc.name fileIO_test_stream_write_async_022
+   * @tc.desc Test the write() interface of class Stream. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_async_022', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_write_async_022');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      let bytesWritten1 = await sr.write(FILE_CONTENT, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      });
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await sr.write(new ArrayBuffer(FILE_CONTENT.length), {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      });
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      sr.closeSync();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_stream_write_async_022 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_STREAM_WRITE_ASYNC_2300
+   * @tc.name fileIO_test_stream_write_async_023
+   * @tc.desc Test the write() interface of class Stream. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_stream_write_async_023', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_stream_write_async_023');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let sr = fileIO.createStreamSync(fpath, 'r+');
+      expect(sr !== null).assertTrue();
+      sr.write(FILE_CONTENT, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      }, (err, bytesWritten1) => {
+        if (err) {
+          console.log('fileIO_test_stream_write_async_023 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        sr.write(new ArrayBuffer(FILE_CONTENT.length), {
+          offset: undefined,
+          length: undefined,
+          encoding: undefined
+        }, (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_stream_write_async_023 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = sr.readSync(new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          sr.closeSync();
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_stream_write_async_023 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 })
 }

storage/storagefileiov9jstest/src/main/js/test/members/copyFile.test.js

@@ -260,6 +260,34 @@ describe('fileIO_fs_copyfile', function () {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_COPY_FILE_SYNC_0900
+   * @tc.name fileIO_copy_file_sync_009
+   * @tc.desc Test copyFileSync() interfaces.
+   * Use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_copy_file_sync_009', 3, async function () {
+    let fpath = await nextFileName('fileIO_copy_file_sync_009');
+    let fpathTarget = fpath + 'tgt';
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.copyFileSync(fpath, fpathTarget, undefined);
+      let stat1 = fileIO.statSync(fpath);
+      let stat2 = fileIO.statSync(fpathTarget);
+      expect(stat1.size == stat2.size).assertTrue();
+      fileIO.unlinkSync(fpath);
+      fileIO.unlinkSync(fpathTarget);
+    } catch (e) {
+      console.log('fileIO_copy_file_sync_009 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_COPY_FILE_ASYNC_0000
    * @tc.name fileIO_copy_file_async_000
@@ -790,5 +818,68 @@ describe('fileIO_fs_copyfile', function () {
       expect(false).assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_COPY_FILE_ASYNC_1800
+   * @tc.name fileIO_copy_file_async_018
+   * @tc.desc Test copyFile() interfaces. Promise
+   * Use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_copy_file_async_018', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_copy_file_async_018');
+    let fpathTarget = fpath + 'tgt';
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      await fileIO.copyFile(fpath, fpathTarget, undefined);
+      let stat1 = fileIO.statSync(fpath);
+      let stat2 = fileIO.statSync(fpathTarget);
+      expect(stat1.size == stat2.size).assertTrue();
+      fileIO.unlinkSync(fpath);
+      fileIO.unlinkSync(fpathTarget);
+      done();
+    } catch (e) {
+      console.log('fileIO_copy_file_async_018 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_COPY_FILE_ASYNC_1900
+   * @tc.name fileIO_copy_file_async_019
+   * @tc.desc Test copyFile() interfaces. Callback
+   * Use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_copy_file_async_019', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_copy_file_async_019');
+    let fpathTarget = fpath + 'tgt';
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.copyFile(fpath, fpathTarget, undefined, (err) => {
+        if (err) {
+          console.log('fileIO_copy_file_async_019 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        let stat1 = fileIO.statSync(fpath);
+        let stat2 = fileIO.statSync(fpathTarget);
+        expect(stat1.size == stat2.size).assertTrue();
+        fileIO.unlinkSync(fpath);
+        fileIO.unlinkSync(fpathTarget);
+        done();
+      });
+    } catch (e) {
+      console.log('fileIO_copy_file_async_019 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/members/createStream.test.js

@@ -88,7 +88,7 @@ describe('fileIO_fs_createStream', function () {
       let sr = fileIO.createStreamSync(fpath, 'r+');
       expect(sr !== null).assertTrue();
       expect(sr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
-      expect(sr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
+      expect(sr.writeSync(FILE_CONTENT, { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -266,7 +266,7 @@ describe('fileIO_fs_createStream', function () {
       let sw = fileIO.createStreamSync(fpath, 'w+');
       expect(sw !== null).assertTrue();
       expect(sw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sw.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -292,7 +292,7 @@ describe('fileIO_fs_createStream', function () {
       let sw = fileIO.createStreamSync(fpath, 'w+');
       expect(sw !== null).assertTrue();
       expect(sw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sw.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -402,7 +402,7 @@ describe('fileIO_fs_createStream', function () {
       let sa = fileIO.createStreamSync(fpath, 'a+');
       expect(sa !== null).assertTrue();
       expect(sa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+      expect(sa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
       sa.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -428,7 +428,7 @@ describe('fileIO_fs_createStream', function () {
       let sa = fileIO.createStreamSync(fpath, 'a+');
       expect(sa !== null).assertTrue();
       expect(sa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sa.closeSync();
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -576,7 +576,7 @@ describe('fileIO_fs_createStream', function () {
       let sr = await fileIO.createStream(fpath, 'r+');
       expect(sr !== null).assertTrue();
       expect(sr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
-      expect(sr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
+      expect(sr.writeSync(FILE_CONTENT, { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -608,7 +608,7 @@ describe('fileIO_fs_createStream', function () {
         }
         expect(sr !== null).assertTrue();
         expect(sr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
-        expect(sr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
+        expect(sr.writeSync(FILE_CONTENT, { offset: 0 }) == FILE_CONTENT.length).assertTrue();
         sr.closeSync();
         fileIO.unlinkSync(fpath);
         done();
@@ -832,7 +832,7 @@ describe('fileIO_fs_createStream', function () {
       let sw = await fileIO.createStream(fpath, 'w+');
       expect(sw !== null).assertTrue();
       expect(sw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sw.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -859,7 +859,7 @@ describe('fileIO_fs_createStream', function () {
       let sw = await fileIO.createStream(fpath, 'w+');
       expect(sw !== null).assertTrue();
       expect(sw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sw.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -891,7 +891,7 @@ describe('fileIO_fs_createStream', function () {
         }
         expect(sw !== null).assertTrue();
         expect(sw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-        expect(sw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+        expect(sw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
         sw.closeSync();
         fileIO.unlinkSync(fpath);
         done();
@@ -923,7 +923,7 @@ describe('fileIO_fs_createStream', function () {
       sa.closeSync();
 
       let sr = fileIO.createStreamSync(fpath, 'r');
-      expect(sr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+      expect(sr.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
       sr.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -1020,7 +1020,7 @@ describe('fileIO_fs_createStream', function () {
       let sa = await fileIO.createStream(fpath, 'a+');
       expect(sa !== null).assertTrue();
       expect(sa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+      expect(sa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
       sa.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -1047,7 +1047,7 @@ describe('fileIO_fs_createStream', function () {
       let sa = await fileIO.createStream(fpath, 'a+');
       expect(sa !== null).assertTrue();
       expect(sa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(sa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(sa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       sa.closeSync();
       fileIO.unlinkSync(fpath);
       done();
@@ -1079,7 +1079,7 @@ describe('fileIO_fs_createStream', function () {
         }
         expect(sa !== null).assertTrue();
         expect(sa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-        expect(sa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+        expect(sa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
         sa.closeSync();
         fileIO.unlinkSync(fpath);
         done();

storage/storagefileiov9jstest/src/main/js/test/members/fdopenStream.test.js

@@ -92,7 +92,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpr = fileIO.fdopenStreamSync(file.fd, 'r+');
       expect(fpr !== null).assertTrue();
       expect(fpr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
-      expect(fpr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
+      expect(fpr.writeSync(FILE_CONTENT, { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       fpr.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -263,7 +263,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpw = fileIO.fdopenStreamSync(file.fd, 'w+');
       expect(fpw !== null).assertTrue();
       expect(fpw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(fpw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(fpw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       fpw.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -359,7 +359,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpa = fileIO.fdopenStreamSync(file.fd, 'a+');
       expect(fpa !== null).assertTrue();
       expect(fpa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(fpa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+      expect(fpa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
       fpa.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -511,7 +511,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpr = await fileIO.fdopenStream(file.fd, 'r+');
       expect(fpr !== null).assertTrue();
       expect(fpr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(fpr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(fpr.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       fpr.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -546,7 +546,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
         }
         expect(fpr !== null).assertTrue();
         expect(fpr.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-        expect(fpr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+        expect(fpr.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
         fpr.closeSync();
         fileIO.closeSync(file);
         fileIO.unlinkSync(fpath);
@@ -714,7 +714,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
 
       let file2 = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
       let fpr = await fileIO.fdopenStream(file2.fd, 'r');
-      expect(fpr.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(fpr.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       fpr.closeSync();
       fileIO.closeSync(file1);
       fileIO.closeSync(file2);
@@ -746,7 +746,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpw = await fileIO.fdopenStream(file.fd, 'w+');
       expect(fpw !== null).assertTrue();
       expect(fpw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(fpw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+      expect(fpw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
       fpw.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -781,7 +781,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
         }
         expect(fpw !== null).assertTrue();
         expect(fpw.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-        expect(fpw.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length).assertTrue();
+        expect(fpw.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length).assertTrue();
         fpw.closeSync();
         fileIO.closeSync(file);
         fileIO.unlinkSync(fpath);
@@ -925,7 +925,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
       let fpa = await fileIO.fdopenStream(file.fd, 'a+');
       expect(fpa !== null).assertTrue();
       expect(fpa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-      expect(fpa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+      expect(fpa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
       fpa.closeSync();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -960,7 +960,7 @@ describe('fileIO_fs_FdOpenStream', async function () {
         }
         expect(fpa !== null).assertTrue();
         expect(fpa.writeSync(FILE_CONTENT) == FILE_CONTENT.length).assertTrue();
-        expect(fpa.readSync(new ArrayBuffer(4096)) == FILE_CONTENT.length * 2).assertTrue();
+        expect(fpa.readSync(new ArrayBuffer(4096), { offset: 0 }) == FILE_CONTENT.length * 2).assertTrue();
         fpa.closeSync();
         fileIO.closeSync(file);
         fileIO.unlinkSync(fpath);

storage/storagefileiov9jstest/src/main/js/test/members/fileLock.test.js

@@ -252,6 +252,64 @@ export default function fileIOFileLock() {
     }
   });
 
+  /**
+   * @tc.number FILE_TEST_FILELOCK_PROMISE_0800
+   * @tc.name fileIO_test_filelock_promise_008
+   * @tc.desc Test lock() interfaces.
+   * Open the file, file.lock(), use default mode = false.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_filelock_promise_008', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_filelock_promise_008');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      await file.lock(undefined);
+      file.unlock();
+      expect(true).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_filelock_promise_008 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number FILE_TEST_FILELOCK_PROMISE_0900
+   * @tc.name fileIO_test_filelock_promise_009
+   * @tc.desc File.trylock(), use default mode = false.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_filelock_promise_009', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_filelock_promise_009');
+    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(undefined);
+      file.unlock();
+      expect(true).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_filelock_promise_009 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number FILE_TEST_FILELOCK_PROMISE_ABNORMAL_0000
    * @tc.name fileIO_test_filelock_promise_abnormal_000
@@ -555,6 +613,40 @@ export default function fileIOFileLock() {
     }
   });
 
+  /**
+   * @tc.number FILE_TEST_FILELOCK_CALLBACK_0300
+   * @tc.name fileIO_test_filelock_callback_003
+   * @tc.desc Test lock() interfaces.
+   * Open the file, file.lock(), use default mode = false.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_filelock_callback_003', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_filelock_callback_003');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      file.lock(undefined, (err) => {
+        if (err) {
+          console.log('fileIO_test_filelock_callback_003 err ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        file.unlock();
+        expect(true).assertTrue();
+        fileIO.closeSync(file);
+        fileIO.unlinkSync(fpath);
+        done();
+      });
+    } catch (e) {
+      console.log('fileIO_test_filelock_callback_003 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number FILE_TEST_FILELOCK_CALLBACK_ABNORMAL_0000
    * @tc.name fileIO_test_filelock_callback_abnormal_000

storage/storagefileiov9jstest/src/main/js/test/members/listFile.test.js

@@ -433,6 +433,87 @@ export default function fileIOListfile() {
       expect(err.code == 13900020 && err.message == 'Invalid argument').assertTrue();
     }
   });
+
+  /**
+  * @tc.number SUB_DF_FILEIO_LISTFILE_SYNC_1100
+  * @tc.name fileIO_test_listfile_sync_011
+  * @tc.desc Test listFileSync() interfaces.
+  * Undefined option arguments, use default options.
+  * @tc.size MEDIUM
+  * @tc.type Function
+  * @tc.level Level 3
+  * @tc.require
+  */
+  it('fileIO_test_listfile_sync_011', 3, async function () {
+    let dpath = await nextFileName('fileIO_test_listfile_sync_011');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_sync_010.txt';
+    let fpath2 = dpath + '/listfile_sync_010.doc';
+    let fpath3 = dpath + '/listfile_sync_010.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_010.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_010.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      let dirents = fileIO.listFileSync(dpath, {
+        listNum: undefined,
+        recursion: undefined,
+        filter:{
+          displayName: undefined,
+          fileSizeOver: undefined,
+          lastModifiedAfter: undefined
+        }
+      });
+      expect(dirents.length == 4).assertTrue();
+      fileIO.rmdirSync(dpath);
+    } catch (err) {
+      console.log('fileIO_test_listfile_sync_011 has failed for ' + err.message + ', code:' + err.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+  * @tc.number SUB_DF_FILEIO_LISTFILE_SYNC_1200
+  * @tc.name fileIO_test_listfile_sync_012
+  * @tc.desc Test listFileSync() interfaces.
+  * Undefined option arguments, use default options.
+  * @tc.size MEDIUM
+  * @tc.type Function
+  * @tc.level Level 3
+  * @tc.require
+  */
+  it('fileIO_test_listfile_sync_012', 3, async function () {
+    let dpath = await nextFileName('fileIO_test_listfile_sync_012');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_sync_011.txt';
+    let fpath2 = dpath + '/listfile_sync_011.doc';
+    let fpath3 = dpath + '/listfile_sync_011.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_011.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_011.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      let dirents = fileIO.listFileSync(dpath, undefined);
+      expect(dirents.length == 4).assertTrue();
+      fileIO.rmdirSync(dpath);
+    } catch (err) {
+      console.log('fileIO_test_listfile_sync_012 has failed for ' + err.message + ', code:' + err.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_LISTFILE_ASYNC_0000
    * @tc.name fileIO_test_listfile_async_000
@@ -1265,5 +1346,177 @@ export default function fileIOListfile() {
       done();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_LISTFILE_ASYNC_2000
+   * @tc.name fileIO_test_listfile_async_020
+   * @tc.desc Test listFile() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_listfile_async_020', 3, async function () {
+    let dpath = await nextFileName('fileIO_test_listfile_async_020');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_async_020.txt';
+    let fpath2 = dpath + '/listfile_async_020.doc';
+    let fpath3 = dpath + '/listfile_async_020.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_020.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_020.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.listFile(dpath, {
+          listNum: undefined,
+          recursion: undefined,
+          filter:{
+            displayName: undefined,
+            fileSizeOver: undefined,
+            lastModifiedAfter: undefined
+          }
+        }, (err, dirents) => {
+          if (err) {
+            console.log('fileIO_test_listfile_async_020 err package ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(dirents.length == 4).assertTrue();
+          fileIO.rmdirSync(dpath);
+      });
+    } catch (e) {
+      console.log('fileIO_test_listfile_async_020 has failed for ' + e.message + ', code:' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_LISTFILE_ASYNC_2100
+   * @tc.name fileIO_test_listfile_async_021
+   * @tc.desc Test listFile() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_listfile_async_021', 3, async function () {
+    let dpath = await nextFileName('fileIO_test_listfile_async_021');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_async_021.txt';
+    let fpath2 = dpath + '/listfile_async_021.doc';
+    let fpath3 = dpath + '/listfile_async_021.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_021.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_021.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.listFile(dpath, undefined, (err, dirents) => {
+        if (err) {
+          console.log('fileIO_test_listfile_async_021 err package ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(dirents.length == 4).assertTrue();
+        fileIO.rmdirSync(dpath);
+      });
+    } catch (e) {
+      console.log('fileIO_test_listfile_async_021 has failed for ' + e.message + ', code:' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_LISTFILE_ASYNC_2200
+   * @tc.name fileIO_test_listfile_async_022
+   * @tc.desc Test listFile() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_listfile_async_022', 3, async function (done) {
+    let dpath = await nextFileName('fileIO_test_listfile_async_022');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_async_022.txt';
+    let fpath2 = dpath + '/listfile_async_022.doc';
+    let fpath3 = dpath + '/listfile_async_022.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_022.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_022.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      let dirents = await fileIO.listFile(dpath, {
+        listNum: undefined,
+        recursion: undefined,
+        filter:{
+          displayName: undefined,
+          fileSizeOver: undefined,
+          lastModifiedAfter: undefined
+        }
+      });
+      expect(dirents.length == 4).assertTrue();
+      fileIO.rmdirSync(dpath);
+      done();
+    } catch (err) {
+      console.log('fileIO_test_listfile_async_022 has failed for ' + err.message + ', code:' + err.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_LISTFILE_ASYNC_2300
+   * @tc.name fileIO_test_listfile_async_023
+   * @tc.desc Test listFile() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_listfile_async_023', 3, async function (done) {
+    let dpath = await nextFileName('fileIO_test_listfile_async_023');
+    let ddpath = dpath + '/second_dir';
+    let fpath1 = dpath + '/listfile_async_023.txt';
+    let fpath2 = dpath + '/listfile_async_023.doc';
+    let fpath3 = dpath + '/listfile_async_023.png';
+    let ffpath1 = ddpath + '/listfile_sync_second_023.txt';
+    let ffpath2 = ddpath + '/listfile_sync_second_023.doc';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath2, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(fpath3, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath1, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath2, FILE_CONTENT)).assertTrue();
+
+    try {
+      let dirents = await fileIO.listFile(dpath, undefined);
+      expect(dirents.length == 4).assertTrue();
+      fileIO.rmdirSync(dpath);
+      done();
+    } catch (err) {
+      console.log('fileIO_test_listfile_async_023 has failed for ' + err.message + ', code:' + err.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/members/moveDir.test.js

@@ -917,5 +917,57 @@ export default function fileIOMoveDir() {
       expect(false).assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_MOVEDIRSYNC_2400
+   * @tc.name fileIO_test_moveDir_async_024
+   * @tc.desc Test moveFile() interface. Promise.
+   * Undefined option arguments, use default mode = DIRMODE_DIRECTORY_THROW_ERR.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_moveDir_async_024', 3, async function (done) {
+    let dpath = await readyFiles('fileIO_test_moveDir_async_024');
+
+    try {
+      await fileIO.moveDir(dpath.srcDir, dpath.destDir, undefined);
+      expect(false).assertTrue();
+    } catch (e) {
+      fileIO.rmdirSync(dpath.baseDir);
+      console.log('fileIO_test_moveDir_async_024 has failed for ' + e.message + ', code: ' + e.code);
+      expect(e.code == 13900032 && e.message == 'Directory not empty').assertTrue();
+      done();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_MOVEDIRSYNC_2500
+   * @tc.name fileIO_test_moveDir_async_025
+   * @tc.desc Test moveFile() interface. Callback.
+   * Undefined option arguments, use default mode = DIRMODE_DIRECTORY_THROW_ERR.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_moveDir_async_025', 3, async function (done) {
+    let dpath = await readyFiles('fileIO_test_moveDir_async_025');
+
+    try {
+      fileIO.moveDir(dpath.srcDir, dpath.destDir, undefined, (err) => {
+        if (err) {
+          fileIO.rmdirSync(dpath.baseDir);
+          console.log('fileIO_test_moveDir_async_025 error: {message: ' + err.message + ', code: ' + err.code + '}');
+          expect(err.code == 13900032 && err.message == 'Directory not empty').assertTrue();
+          done();
+        }
+      });
+    } catch (e) {
+      console.log('fileIO_test_moveDir_async_025 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }
\ No newline at end of file

storage/storagefileiov9jstest/src/main/js/test/members/moveFile.test.js

@@ -188,6 +188,36 @@ export default function fileIOMoveFile() {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_MOVEFILE_SYNC_0700
+   * @tc.name fileIO_test_moveFile_sync_007
+   * @tc.desc Test moveFileSync() interface.
+   * Undefined option arguments, use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_moveFile_sync_007', 3, async function () {
+    let dpath = await nextFileName('fileIO_test_moveFile_sync_007');
+    let fpath = dpath + '/file_015.txt';
+    let ddpath = dpath + '/dir_015';
+    let ffpath = ddpath + '/file_015.txt';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.moveFileSync(fpath, ffpath, undefined);
+      let stat = fileIO.statSync(ffpath);
+      expect(stat.size == FILE_CONTENT.length).assertTrue();
+      fileIO.rmdirSync(dpath);
+    } catch (e) {
+      console.log('fileIO_test_moveFile_sync_007 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_MOVEFILE_ASYNC_0000
    * @tc.name fileIO_test_moveFile_async_000
@@ -532,5 +562,74 @@ export default function fileIOMoveFile() {
       expect(false).assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_MOVEFILE_ASYNC_1100
+   * @tc.name fileIO_test_moveFile_async_011
+   * @tc.desc Test moveFile() interface. Promise.
+   * Undefined option arguments, use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_moveFile_async_011', 3, async function (done) {
+    let dpath = await nextFileName('fileIO_test_moveFile_async_011');
+    let fpath = dpath + '/file_016.txt';
+    let ddpath = dpath + '/dir_016';
+    let ffpath = ddpath + '/file_016.txt';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath, '')).assertTrue();
+
+    try {
+      await fileIO.moveFile(fpath, ffpath, undefined);
+      let stat = fileIO.statSync(ffpath);
+      expect(stat.size == FILE_CONTENT.length).assertTrue();
+      fileIO.rmdirSync(dpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_moveFile_async_011 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_MOVEFILE_ASYNC_1200
+   * @tc.name fileIO_test_moveFile_async_012
+   * @tc.desc Test moveFile() interface. Callback.
+   * Undefined option arguments, use default mode = 0.
+   * @tc.size MEDIUM
+   * @tc.type Function
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_moveFile_async_012', 3, async function (done) {
+    let dpath = await nextFileName('fileIO_test_moveFile_async_012');
+    let fpath = dpath + '/file_017.txt';
+    let ddpath = dpath + '/dir_017';
+    let ffpath = ddpath + '/file_017.txt';
+    fileIO.mkdirSync(dpath);
+    fileIO.mkdirSync(ddpath);
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    expect(prepareFile(ffpath, '')).assertTrue();
+
+    try {
+      fileIO.moveFile(fpath, ffpath, undefined, (err) => {
+        if (err) {
+          console.log('fileIO_test_moveFile_async_012 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        let stat = fileIO.statSync(ffpath);
+        expect(stat.size == FILE_CONTENT.length).assertTrue();
+        fileIO.rmdirSync(dpath);
+        done();
+      });
+    } catch (e) {
+      console.log('fileIO_test_moveFile_async_012 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
   });
+});
 }
\ No newline at end of file

storage/storagefileiov9jstest/src/main/js/test/members/open.test.js

@@ -94,7 +94,7 @@ export default function fileIOOpen() {
       let readlen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
       expect(readlen == FILE_CONTENT.length).assertTrue();
       let length = 20;
-      let bytesWritten = fileIO.writeSync(file.fd, new ArrayBuffer(length));
+      let bytesWritten = fileIO.writeSync(file.fd, new ArrayBuffer(length), { offset: 0 });
       expect(bytesWritten == length).assertTrue();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
@@ -398,6 +398,36 @@ export default function fileIOOpen() {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_OPEN_SYNC_1500
+   * @tc.name fileIO_test_open_sync_015
+   * @tc.desc Test openSync() interfaces.
+   * Undefined option arguments, use default mode = 0o0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_open_sync_015', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_open_sync_015');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    let file;
+
+    try {
+      file = fileIO.openSync(fpath, undefined);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readlen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+      expect(readlen == FILE_CONTENT.length).assertTrue();
+      fileIO.writeSync(file.fd, new ArrayBuffer(4096));
+      expect(false).assertTrue();
+    } catch (e) {
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      console.log('fileIO_test_open_sync_015 has failed for ' + e.message + ', code: ' + e.code);
+      expect(e.code == 13900008 && e.message == 'Bad file descriptor').assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_OPEN_ASYNC_0000
    * @tc.name fileIO_test_open_async_000
@@ -1295,5 +1325,77 @@ export default function fileIOOpen() {
       expect(false).assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_OPEN_ASYNC_3100
+   * @tc.name fileIO_test_open_async_031
+   * @tc.desc Test open() interfaces. Promise.
+   * Undefined option arguments, use default mode = 0o0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_open_async_031', 0, async function (done) {
+    let fpath = await nextFileName('fileIO_test_open_async_031');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    let file;
+
+    try {
+      file = await fileIO.open(fpath, undefined);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+      expect(readLen == FILE_CONTENT.length).assertTrue();
+      fileIO.writeSync(file.fd, new ArrayBuffer(4096));
+      expect(false).assertTrue();
+    } catch (e) {
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      console.log('fileIO_test_open_async_031 has failed for ' + e.message + ', code: ' + e.code);
+      expect(e.code == 13900008 && e.message == 'Bad file descriptor').assertTrue();
+      done();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_OPEN_ASYNC_3200
+   * @tc.name fileIO_test_open_async_032
+   * @tc.desc Test open() interfaces. Callback.
+   * Undefined option arguments, use default mode = 0o0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_open_async_032', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_open_async_032');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.open(fpath, undefined, (err, file) => {
+        if (err) {
+          console.log('fileIO_test_open_async_032 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(isIntNum(file.fd)).assertTrue();
+        let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+        expect(readLen == FILE_CONTENT.length).assertTrue();
+        fileIO.write(file.fd, new ArrayBuffer(4096), (err, bytesWritten) => {
+          if (err) {
+            fileIO.closeSync(file);
+            fileIO.unlinkSync(fpath);
+            console.log('fileIO_test_open_async_032 error: {message: ' + err.message + ', code: ' + err.code + '}');
+            expect(err.code == 13900008 && err.message == 'Bad file descriptor').assertTrue();
+            done();
+          } else {
+            expect(false).assertTrue();
+          }
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_open_async_032 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/members/read.test.js

@@ -24,7 +24,7 @@ export default function fileIORead() {
    * @tc.number SUB_DF_FILEIO_READ_SYNC_0000
    * @tc.name fileIO_test_read_sync_000
    * @tc.desc Test readSync() interfaces.
-   * Open the file in read-only mode, verifying the normal read function.
+   * Open the file in read-only mode, default read from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 0
@@ -37,8 +37,10 @@ export default function fileIORead() {
     try {
       let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
       expect(isIntNum(file.fd)).assertTrue();
-      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      let readLen1 = fileIO.readSync(file.fd, new ArrayBuffer(16));
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = fileIO.readSync(file.fd, new ArrayBuffer(8));
+      expect(readLen2 == 0).assertTrue();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -80,7 +82,7 @@ export default function fileIORead() {
    * @tc.number SUB_DF_FILEIO_READ_SYNC_0200
    * @tc.name fileIO_test_read_sync_002
    * @tc.desc Test readSync() interfaces.
-   * Open the file in read-only mode, reading the file with length < 0(Read normal).
+   * Open the file in read-only mode, reading the file with length = -1((0 < length < buffer.size)).
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 3
@@ -89,19 +91,20 @@ export default function fileIORead() {
   it('fileIO_test_read_sync_002', 0, async function () {
     let fpath = await nextFileName('fileIO_test_read_sync_002');
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+    const invalidLength = -1;
 
     try {
-      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
       expect(isIntNum(file.fd)).assertTrue();
-      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), {
-        length: -1,
+      fileIO.readSync(file.fd, new ArrayBuffer(4096), {
+        length: invalidLength,
       });
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      expect(false).assertTrue();
+    } catch (e) {
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
-    } catch (e) {
       console.log('fileIO_test_read_sync_002 has failed for ' + e.message + ', code: ' + e.code);
-      expect(false).assertTrue();
+      expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
     }
   });
 
@@ -206,11 +209,12 @@ export default function fileIORead() {
     let fpath = await nextFileName('fileIO_test_read_sync_006');
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
     let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+    const invalidOffset = -1;
 
     try {
       expect(isIntNum(file.fd)).assertTrue();
       fileIO.readSync(file.fd, new ArrayBuffer(4096), {
-        offset: -1,
+        offset: invalidOffset,
       });
       expect(false).assertTrue();
     } catch (e) {
@@ -332,11 +336,75 @@ export default function fileIORead() {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_SYNC_1100
+   * @tc.name fileIO_test_read_sync_011
+   * @tc.desc Test readSync() interfaces.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_sync_011', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_read_sync_011');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen1 = fileIO.readSync(file.fd, new ArrayBuffer(16), undefined);
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = fileIO.readSync(file.fd, new ArrayBuffer(8), undefined);
+      expect(readLen2 == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_read_sync_011 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_SYNC_1200
+   * @tc.name fileIO_test_read_sync_012
+   * @tc.desc Test readSync() interfaces.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_sync_012', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_read_sync_012');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen1 = fileIO.readSync(file.fd, new ArrayBuffer(16), {
+        offset: undefined,
+        length: undefined,
+      });
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = fileIO.readSync(file.fd, new ArrayBuffer(8), {
+        offset: undefined,
+        length: undefined,
+      });
+      expect(readLen2 == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_read_sync_012 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_READ_ASYNC_0000
    * @tc.name fileIO_test_read_async_000
    * @tc.desc Test read() interfaces. Promise.
-   * Open the file in read-only mode, verifying the normal read function.
+   * Open the file in read-only mode, default read from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 0
@@ -349,8 +417,10 @@ export default function fileIORead() {
     try {
       let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
       expect(isIntNum(file.fd)).assertTrue();
-      let readLen = await fileIO.read(file.fd, new ArrayBuffer(4096));
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      let readLen1 = await fileIO.read(file.fd, new ArrayBuffer(16));
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await fileIO.read(file.fd, new ArrayBuffer(8));
+      expect(readLen2 == 0).assertTrue();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
       done();
@@ -364,7 +434,7 @@ export default function fileIORead() {
    * @tc.number SUB_DF_FILEIO_READ_ASYNC_0100
    * @tc.name fileIO_test_read_async_001
    * @tc.desc Test read() interfaces. Callback.
-   * Open the file in read-only mode, verifying the normal read function.
+   * Open the file in read-only mode, default read from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 3
@@ -377,15 +447,22 @@ export default function fileIORead() {
     try {
       let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
       expect(isIntNum(file.fd)).assertTrue();
-      fileIO.read(file.fd, new ArrayBuffer(4096), (err, readlen) => {
-        if(err) {
-          console.log('fileIO_test_read_async_001 err package: ' + JSON.stringify(err));
+      fileIO.read(file.fd, new ArrayBuffer(16), (err, readlen1) => {
+        if (err) {
+          console.log('fileIO_test_read_async_001 err package1: ' + JSON.stringify(err));
           expect(false).assertTrue();
         }
-        expect(readlen == FILE_CONTENT.length).assertTrue();
-        fileIO.closeSync(file);
-        fileIO.unlinkSync(fpath);
-        done();
+        expect(readlen1 == FILE_CONTENT.length).assertTrue();
+        fileIO.read(file.fd, new ArrayBuffer(8), (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_read_async_001 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
       });
     } catch (e) {
       console.log('fileIO_test_read_async_001 has failed for ' + e.message + ', code: ' + e.code);
@@ -891,28 +968,30 @@ export default function fileIORead() {
    * @tc.number SUB_DF_FILEIO_READ_ASYNC_1800
    * @tc.name fileIO_test_read_async_018
    * @tc.desc Test read() interfaces.
-   * Open the file in read-only mode, reading the file with length = -1(Read normal).
+   * Open the file in read-only mode, reading the file with length = -1(0 < length < buffer.size).
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 3
    * @tc.require
    */
-  it('fileIO_test_read_async_018', 0, async function () {
+  it('fileIO_test_read_async_018', 0, async function (done) {
     let fpath = await nextFileName('fileIO_test_read_async_018');
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
     let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+    const invalidLength = -1;
 
     try {
       expect(isIntNum(file.fd)).assertTrue();
-      let readLen = await fileIO.read(file.fd, new ArrayBuffer(4096), {
-        length: -1,
+      await fileIO.read(file.fd, new ArrayBuffer(4096), {
+        length: invalidLength,
       });
-      expect(readLen == FILE_CONTENT.length).assertTrue();
+      expect(false).assertTrue();
+    } catch (e) {
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
-    } catch (e) {
       console.log('fileIO_test_read_async_018 has failed for ' + e.message + ', code: ' + e.code);
-      expect(false).assertTrue();
+      expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
+      done();
     }
   });
 
@@ -947,5 +1026,157 @@ export default function fileIORead() {
       expect(false).assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_ASYNC_2000
+   * @tc.name fileIO_test_read_async_020
+   * @tc.desc Test read() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_async_020', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_read_async_020');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen1 = await fileIO.read(file.fd, new ArrayBuffer(16), undefined);
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await fileIO.read(file.fd, new ArrayBuffer(8), undefined);
+      expect(readLen2 == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_read_async_020 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_ASYNC_2100
+   * @tc.name fileIO_test_read_async_021
+   * @tc.desc Test read() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_async_021', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_read_async_021');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.read(file.fd, new ArrayBuffer(16), undefined, (err, readlen1) => {
+        if(err) {
+          console.log('fileIO_test_read_async_021 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(readlen1 == FILE_CONTENT.length).assertTrue();
+        fileIO.read(file.fd, new ArrayBuffer(8), undefined, (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_read_async_021 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_read_async_021 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_ASYNC_2200
+   * @tc.name fileIO_test_read_async_022
+   * @tc.desc Test read() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_async_022', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_read_async_022');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen1 = await fileIO.read(file.fd, new ArrayBuffer(4096), {
+        offset: undefined,
+        length: undefined,
+      });
+      expect(readLen1 == FILE_CONTENT.length).assertTrue();
+      let readLen2 = await fileIO.read(file.fd, new ArrayBuffer(8), {
+        offset: undefined,
+        length: undefined,
+      });
+      expect(readLen2 == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_read_async_022 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_ASYNC_2300
+   * @tc.name fileIO_test_read_async_023
+   * @tc.desc Test read() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_read_async_023', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_read_async_023');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_ONLY);
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.read(file.fd, new ArrayBuffer(16), {
+        offset: undefined,
+        length: undefined,
+      }, (err, readLen1) => {
+        if(err) {
+          console.log('fileIO_test_read_async_011 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(readLen1 == FILE_CONTENT.length).assertTrue();
+        fileIO.read(file.fd, new ArrayBuffer(8), {
+          offset: undefined,
+          length: undefined,
+        }, (err, readLen2) => {
+          if (err) {
+            console.log('fileIO_test_read_async_001 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(readLen2 == 0).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_read_async_023 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/members/readtext.test.js

@@ -119,7 +119,7 @@ describe('fileIO_fs_readtext', function () {
       expect(str == FILE_CONTENT.substring(1, FILE_CONTENT.length + 1)).assertTrue();
       fileIO.unlinkSync(fpath);
     } catch (e) {
-      console.log('fileIO_test_readtext_sync_002 has failed for ' + e.message + ', code: ' + e.code);
+      console.log('fileIO_test_readtext_sync_003 has failed for ' + e.message + ', code: ' + e.code);
       expect(false).assertTrue();
     }
   });
@@ -242,6 +242,58 @@ describe('fileIO_fs_readtext', function () {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_SYNC_0900
+   * @tc.name fileIO_test_readtext_sync_009
+   * @tc.desc Test readtextSync() interfaces.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+  */
+  it('fileIO_test_readtext_sync_009', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_readtext_sync_009');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let str = fileIO.readTextSync(fpath, undefined);
+      expect(str == FILE_CONTENT).assertTrue();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_readtext_sync_009 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_SYNC_1000
+   * @tc.name fileIO_test_readtext_sync_010
+   * @tc.desc Test readtextSync() interfaces.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+  */
+  it('fileIO_test_readtext_sync_010', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_readtext_sync_010');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let str = fileIO.readTextSync(fpath, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      });
+      expect(str == FILE_CONTENT).assertTrue();
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_readtext_sync_010 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_READ_TEXT_ASYNC_0000
    * @tc.name fileIO_test_readtext_async_000
@@ -694,5 +746,123 @@ describe('fileIO_fs_readtext', function () {
       done();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_ASYNC_1600
+   * @tc.name fileIO_test_readtext_async_016
+   * @tc.desc Test readtext() interfaces. Promise.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_readtext_async_016', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_readtext_async_016');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let str = await fileIO.readText(fpath, undefined);
+      expect(str == FILE_CONTENT).assertTrue();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_readtext_async_016 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_ASYNC_1700
+   * @tc.name fileIO_test_readtext_async_017
+   * @tc.desc Test readtext() interfaces. Callback.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_readtext_async_017', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_readtext_async_017');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.readText(fpath, undefined, (err, str) => {
+        if (err) {
+          console.log('fileIO_test_readtext_async_017 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(str == FILE_CONTENT).assertTrue();
+        fileIO.unlinkSync(fpath);
+        done();
+      });
+    } catch (e) {
+      console.log('fileIO_test_readtext_async_017 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_ASYNC_1800
+   * @tc.name fileIO_test_readtext_async_018
+   * @tc.desc Test readtext() interfaces. Promise.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_readtext_async_018', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_readtext_async_018');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let str = await fileIO.readText(fpath, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      });
+      expect(str == FILE_CONTENT).assertTrue();
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_readtext_async_018 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_READ_TEXT_ASYNC_1900
+   * @tc.name fileIO_test_readtext_async_019
+   * @tc.desc Test readtext() interfaces. Callback.
+   * Use default option.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_readtext_async_019', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_readtext_async_019');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      fileIO.readText(fpath, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined
+      }, (err, str) => {
+        if (err) {
+          console.log('fileIO_test_readtext_async_019 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(str == FILE_CONTENT).assertTrue();
+        fileIO.unlinkSync(fpath);
+        done();
+      });
+    } catch (e) {
+      console.log('fileIO_test_readtext_async_019 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 });
 }

storage/storagefileiov9jstest/src/main/js/test/members/truncate.test.js

@@ -273,6 +273,69 @@ import {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_TRUNCATE_ASYNC_0800
+   * @tc.name fileIO_truncate_async_008
+   * @tc.desc Test the truncate() interface. Promise.
+   * Use default truncateLen = 0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_truncate_async_008', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_truncate_async_008');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      await fileIO.truncate(fpath, undefined);
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+      expect(readLen == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_truncate_async_008 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_TRUNCATE_ASYNC_0900
+   * @tc.name fileIO_truncate_async_009
+   * @tc.desc Test the truncate() interface. Callback.
+   * Use default truncateLen = 0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_truncate_async_009', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_truncate_async_009');
+    expect(prepareFile(fpath, 'truncate')).assertTrue();
+    let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+
+    try {
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.truncate(file.fd, undefined, (err) => {
+        if (err) {
+          console.log('fileIO_truncate_async_009 error package: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+        expect(readLen == 0).assertTrue();
+        fileIO.closeSync(file);
+        fileIO.unlinkSync(fpath);
+        done();
+      });
+    } catch(e) {
+      console.log('fileIO_truncate_async_009 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_TRUNCATE_SYNC_0000
    * @tc.name fileIO_test_truncate_sync_000
@@ -388,5 +451,33 @@ import {
       expect(e.code == 13900020 && e.message == 'Invalid argument').assertTrue();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_TRUNCATE_SYNC_0500
+   * @tc.name fileIO_test_truncate_sync_005
+   * @tc.desc Test truncateSync() interfaces.
+   * Use default truncateLen = 0.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_truncate_sync_005', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_truncate_sync_005');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+
+    try {
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.truncateSync(file.fd, undefined);
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096));
+      expect(readLen == 0).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_truncate_sync_005 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 })
 }

storage/storagefileiov9jstest/src/main/js/test/members/write.test.js

@@ -24,7 +24,7 @@ export default function fileIOWrite() {
    * @tc.number SUB_DF_FILEIO_WRITE_SYNC_0000
    * @tc.name fileIO_test_write_sync_000
    * @tc.desc Test writeSync() interfaces.
-   * Open the file in write-only mode, verifying the normal write function.
+   * Open the file in write-only mode, default write from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 0
@@ -35,10 +35,14 @@ export default function fileIOWrite() {
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
 
     try {
-      let file = fileIO.openSync(fpath, fileIO.OpenMode.WRITE_ONLY);
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
       expect(isIntNum(file.fd)).assertTrue();
-      let bytesWritten = fileIO.writeSync(file.fd, FILE_CONTENT);
-      expect(bytesWritten == FILE_CONTENT.length).assertTrue();
+      let bytesWritten1 = fileIO.writeSync(file.fd, FILE_CONTENT);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = fileIO.writeSync(file.fd, new ArrayBuffer(FILE_CONTENT.length));
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
     } catch (e) {
@@ -325,11 +329,80 @@ export default function fileIOWrite() {
     }
   });
 
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_SYNC_1100
+   * @tc.name fileIO_test_write_sync_011
+   * @tc.desc Test writeSync() interfaces.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_sync_011', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_write_sync_011');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      let bytesWritten1 = fileIO.writeSync(file.fd, FILE_CONTENT, undefined);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = fileIO.writeSync(file.fd, new ArrayBuffer(FILE_CONTENT.length), undefined);
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_write_sync_011 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_SYNC_1200
+   * @tc.name fileIO_test_write_sync_012
+   * @tc.desc Test writeSync() interfaces.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_sync_012', 3, async function () {
+    let fpath = await nextFileName('fileIO_test_write_sync_012');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      let bytesWritten1 = fileIO.writeSync(file.fd, FILE_CONTENT, {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined,
+      });
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = fileIO.writeSync(file.fd, new ArrayBuffer(FILE_CONTENT.length), {
+        offset: undefined,
+        length: undefined,
+        encoding: undefined,
+      });
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+    } catch (e) {
+      console.log('fileIO_test_write_sync_012 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
   /**
    * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_0000
    * @tc.name fileIO_test_write_async_000
    * @tc.desc Test write() interfaces. Promise.
-   * Open the file in write-only mode, verifying the normal write function.
+   * Open the file in write-only mode, default write from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 0
@@ -340,10 +413,14 @@ export default function fileIOWrite() {
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
 
     try {
-      let file = fileIO.openSync(fpath, fileIO.OpenMode.WRITE_ONLY);
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
       expect(isIntNum(file.fd)).assertTrue();
-      let bytesWritten = await fileIO.write(file.fd, FILE_CONTENT);
-      expect(bytesWritten == FILE_CONTENT.length).assertTrue();
+      let bytesWritten1 = await fileIO.write(file.fd, FILE_CONTENT);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length));
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
       fileIO.closeSync(file);
       fileIO.unlinkSync(fpath);
       done();
@@ -357,7 +434,7 @@ export default function fileIOWrite() {
    * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_0100
    * @tc.name fileIO_test_write_async_001
    * @tc.desc Test write() interfaces. Callback.
-   * Open the file in write-only mode, verifying the normal write function.
+   * Open the file in write-only mode, default write from current offset.
    * @tc.size MEDIUM
    * @tc.type Functoin
    * @tc.level Level 3
@@ -368,13 +445,27 @@ export default function fileIOWrite() {
     expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
 
     try {
-      let file = fileIO.openSync(fpath, fileIO.OpenMode.WRITE_ONLY);
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
       expect(isIntNum(file.fd)).assertTrue();
-      let bytesWritten = await fileIO.write(file.fd, FILE_CONTENT);
-      expect(bytesWritten == FILE_CONTENT.length).assertTrue();
-      fileIO.closeSync(file);
-      fileIO.unlinkSync(fpath);
-      done();
+      fileIO.write(file.fd, FILE_CONTENT, (err, bytesWritten1) => {
+        if (err) {
+          console.log('fileIO_test_write_async_001 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length), (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_write_async_001 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
     } catch (e) {
       console.log('fileIO_test_write_async_001 has failed for ' + e.message + ', code: ' + e.code);
       expect(false).assertTrue();
@@ -976,5 +1067,169 @@ export default function fileIOWrite() {
       done();
     }
   });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_2100
+   * @tc.name fileIO_test_write_async_021
+   * @tc.desc Test write() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_async_021', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_write_async_021');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      let bytesWritten1 = await fileIO.write(file.fd, FILE_CONTENT, undefined);
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length), undefined);
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_write_async_021 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_2200
+   * @tc.name fileIO_test_write_async_022
+   * @tc.desc Test write() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_async_022', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_write_async_022');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.write(file.fd, FILE_CONTENT, undefined, (err, bytesWritten1) => {
+        if (err) {
+          console.log('fileIO_test_write_async_022 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length), undefined, (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_write_async_022 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_write_async_022 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_2300
+   * @tc.name fileIO_test_write_async_023
+   * @tc.desc Test write() interfaces. Promise.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_async_023', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_write_async_023');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      let bytesWritten1 = await fileIO.write(file.fd, FILE_CONTENT, {
+        length: undefined,
+        offset: undefined,
+        encoding: undefined,
+      });
+      expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+      let bytesWritten2 = await fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length), {
+        length: undefined,
+        offset: undefined,
+        encoding: undefined,
+      });
+      expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+      let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+      expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+      fileIO.closeSync(file);
+      fileIO.unlinkSync(fpath);
+      done();
+    } catch (e) {
+      console.log('fileIO_test_write_async_023 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
+
+  /**
+   * @tc.number SUB_DF_FILEIO_WRITE_ASYNC_2400
+   * @tc.name fileIO_test_write_async_024
+   * @tc.desc Test write() interfaces. Callback.
+   * Undefined option arguments, use default options.
+   * @tc.size MEDIUM
+   * @tc.type Functoin
+   * @tc.level Level 3
+   * @tc.require
+   */
+  it('fileIO_test_write_async_024', 3, async function (done) {
+    let fpath = await nextFileName('fileIO_test_write_async_024');
+    expect(prepareFile(fpath, FILE_CONTENT)).assertTrue();
+
+    try {
+      let file = fileIO.openSync(fpath, fileIO.OpenMode.READ_WRITE);
+      expect(isIntNum(file.fd)).assertTrue();
+      fileIO.write(file.fd, FILE_CONTENT, {
+        length: undefined,
+        offset: undefined,
+        encoding: undefined,
+      }, (err, bytesWritten1) => {
+        if (err) {
+          console.log('fileIO_test_write_async_011 err package1: ' + JSON.stringify(err));
+          expect(false).assertTrue();
+        }
+        expect(bytesWritten1 == FILE_CONTENT.length).assertTrue();
+        fileIO.write(file.fd, new ArrayBuffer(FILE_CONTENT.length), {
+          length: undefined,
+          offset: undefined,
+          encoding: undefined,
+        }, (err, bytesWritten2) => {
+          if (err) {
+            console.log('fileIO_test_write_async_005 err package2: ' + JSON.stringify(err));
+            expect(false).assertTrue();
+          }
+          expect(bytesWritten2 == FILE_CONTENT.length).assertTrue();
+          let readLen = fileIO.readSync(file.fd, new ArrayBuffer(4096), { offset: 0 });
+          expect(readLen == FILE_CONTENT.length * 2).assertTrue();
+          fileIO.closeSync(file);
+          fileIO.unlinkSync(fpath);
+          done();
+        });
+      });
+    } catch (e) {
+      console.log('fileIO_test_write_async_024 has failed for ' + e.message + ', code: ' + e.code);
+      expect(false).assertTrue();
+    }
+  });
 })
 }