diff --git a/interfaces/test/unittest/BUILD.gn b/interfaces/test/unittest/BUILD.gn
index 341f3526966017a1d054cc69688d3e481a9ae9d4..d62d0e5481a8d2d62d72f530a8327189365cc023 100644
--- a/interfaces/test/unittest/BUILD.gn
+++ b/interfaces/test/unittest/BUILD.gn
@@ -17,5 +17,6 @@ group("unittest") {
     "class_file:class_file_test",
     "filemgmt_libn_test:filemgmt_libn_test",
     "remote_uri:remote_uri_test",
+    "napi_test/mode_fs_test:FileApiJsTest",
   ]
 }
diff --git a/interfaces/test/unittest/napi_test/mode_fs_test/BUILD.gn b/interfaces/test/unittest/napi_test/mode_fs_test/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..6686224a326c0cd392f452e34d1da3fb6f404951
--- /dev/null
+++ b/interfaces/test/unittest/napi_test/mode_fs_test/BUILD.gn
@@ -0,0 +1,24 @@
+# Copyright (C) 2023 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/test.gni")
+
+module_output_path = "file_api/napi"
+
+ohos_js_unittest("FileApiJsTest") {
+  module_out_path = module_output_path
+
+  hap_profile = "./config.json"
+
+  certificate_profile = "./openharmony_sx.p7b"
+}
diff --git a/interfaces/test/unittest/napi_test/mode_fs_test/FsCopyTest.js b/interfaces/test/unittest/napi_test/mode_fs_test/FsCopyTest.js
new file mode 100644
index 0000000000000000000000000000000000000000..495a1992af0313de30bf952d26dd6ffb6d238479
--- /dev/null
+++ b/interfaces/test/unittest/napi_test/mode_fs_test/FsCopyTest.js
@@ -0,0 +1,800 @@
+/*
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fs from '@ohos.file.fs';
+import fileuri from '@ohos.file.fileuri';
+
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
+
+const TAG = 'FsCopyTest';
+describe("FsCopyTest", function () {
+  let context = getContext(this);
+  let pathDir = context.filesDir;
+  let srcDirPathLocal = this.pathDir + "/src";
+  let srcFilePathLocal = this.srcDirPathLocal + '/srcFile.txt';
+  let dstDirPathLocal = this.pathDir + "/dest";
+  let dstFilePathLocal = this.dstDirPathLocal + '/dstFile.txt';
+
+  let srcDirUriLocal = fileuri.getUriFromPath(this.srcDirPathLocal);
+  let srcFileUriLocal = fileuri.getUriFromPath(this.srcFilePathLocal);
+  let dstDirUriLocal = fileuri.getUriFromPath(this.dstDirPathLocal);
+  let dstFileUriLocal = fileuri.getUriFromPath(this.dstFilePathLocal);
+
+  beforeAll(function () {
+    console.info(TAG, 'beforeAll called')
+  });
+
+  afterAll(function () {
+    console.info(TAG, 'afterAll called')
+  });
+
+  beforeEach(function () {
+    console.info(TAG, 'beforeEach called')
+  });
+
+  afterEach(function () {
+    console.info(TAG, 'afterEach called')
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test001
+   * @tc.desc:test fs.copy with wrong params
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test001", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test001 start.');
+    try {
+      fs.copy("aaa", "bbb", (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test001 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test001 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test001 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test002
+   * @tc.desc:test fs.copy with sandbox path
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test002", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test002 start.');
+    try {
+      fs.copy(this.pathDir, "bbb", (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test002 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test002 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test002 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test003
+   * @tc.desc:test fs.copy with not exist dir
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test003", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test003 start.');
+    try {
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test003 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test003 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test003 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test004
+   * @tc.desc:test fs.copy dir to itself
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test004", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test004 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test004 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test004 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test004 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test005
+   * @tc.desc:test fs.copy, copy file, src isn't exist
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test005", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test005 start.');
+    try {
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcFileUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test005 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test005 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test005 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test006
+   * @tc.desc:test fs.copy, copy file to file
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test006", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test006 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test006 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test006 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test006 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test007
+   * @tc.desc:test fs.copy, copy file to dir
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test007", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test007 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test007 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect(true).assertTrue();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test007 success. ");
+          expect().assertFail();
+          done();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test007 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test008
+   * @tc.desc:test fs.copy, copy dir to dir
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test008", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test008 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test008 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test008 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test008 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+    * @tc.name:Fs_Copy_Test009
+    * @tc.desc:test fs.copy, copy file and write the contents but dest isn't exist
+    * @tc.type: FUNC
+    * @tc.require: issueNumber
+    */
+  it("Fs_Copy_Test009", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test009 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test009 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test009 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test009 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+    * @tc.name:Fs_Copy_Test010
+    * @tc.desc:test fs.copy, copy dir and file in the src path 
+    * @tc.type: FUNC
+    * @tc.require: issueNumber
+    */
+  it("Fs_Copy_Test010", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test010 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test0010 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test0010 success. ");
+          expect(true).assertTrue();
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test010 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test011
+   * @tc.desc:test fs.copy, copy file to file with listener
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test011", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test011 start.');
+    try {
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = fs.CopyOptions = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test011 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test011 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test011 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test012
+   * @tc.desc:test fs.copy, copy dir to dir with listener
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test012", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test012 start.');
+    try {
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test012 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test012 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test012 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test013
+   * @tc.desc:test fs.copy, copy file to file with listener promise
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test013", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test013 start.');
+    try {
+      let progress = fs.Progress;
+      let progressListener = (progress) => {
+        console.info("progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      };
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test011 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test011 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test011 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test014
+   * @tc.desc:test fs.copy, copy dir to dir with listener promise
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test014", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test014 start.');
+    try {
+      let progress = fs.Progress;
+      let progressListener = (progress) => {
+        console.info("progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      };
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test012 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test012 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test012 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test015
+   * @tc.desc:test fs.copy, copy file 2 times
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test015", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test015 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener_first in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test015_first failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test015_first success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test015_first failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+
+    try {
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener_second in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.copy(this.srcDirUriLocal, this.dstDirUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test015_second failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test015_second success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test015_second failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test016
+   * @tc.desc:test fs.copy, copy empty file
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test016", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test016 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test016 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test016 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test016 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test017
+   * @tc.desc:test fs.copy, copy empty dir
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test017", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test017 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcDirPathLocal, this.dstDirUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test017 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test017 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test017 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test018
+   * @tc.desc:test fs.copy file to itself
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test018", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test018 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test018 failed, with error message: " + err.message + ", error code: " + err.code);
+        } else {
+          console.info(TAG, "Fs_Copy_Test018 success. ");
+        }
+        expect().assertFail();
+        done();
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test018 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect(true).assertTrue();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test019
+   * @tc.desc:test fs.copy, copy 1KB file
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test019", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test019 start.');
+    try {
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener_second in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      let content = 't'.repeat(1024);
+      fs.writeSync(file.fd, content);
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test019 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test019 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test019 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test020
+   * @tc.desc:test fs.copy, copy 1000MB file
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test020", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test020 start.');
+    try {
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener_second in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      let content = 't'.repeat(1024*1024*1024);
+      fs.writeSync(file.fd, content);
+      fs.closeSync(file);
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test020 failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test020 success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test020 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test021
+   * @tc.desc:test fs.copy, copy file 10 times
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test021", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test021 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      // 执行拷贝操作10次
+      for (let i = 0; i < 10; i++) {
+        const newDestinationFilePath = `${dstFileUriLocal}_${i}`;
+        fs.copy(this.srcFileUriLocal, newDestinationFilePath, (err) => {
+          if (err) {
+            console.info(TAG, "Fs_Copy_Test021 failed, with error message: " + err.message + ", error code: " + err.code);
+            expect().assertFail();
+            done();
+          } else {
+            console.info(TAG, "Fs_Copy_Test021 success. ");
+            expect(true).assertTrue();
+          }
+        })
+      }
+    } catch (err) {
+      console.error("Fs_Copy_Test021 failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+
+  /*
+   * @tc.name:Fs_Copy_Test022
+   * @tc.desc:test fs.copy, copy file 10 times
+   * @tc.type: FUNC
+   * @tc.require: issueNumber
+   */
+  it("Fs_Copy_Test022", 0, async function (done) {
+    console.info(TAG, 'Fs_Copy_Test022 start.');
+    try {
+      fs.mkdirSync(this.srcDirPathLocal);
+      fs.mkdirSync(this.dstDirUriLocal);
+      let file = fs.openSync(this.srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      fs.writeSync(file.fd, 'ttttttttttttt');
+      fs.closeSync(file);
+      let progress = fs.Progress;
+      let progressListener = fs.ProgressListener((progress) => {
+        console.info("progressListener_first in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
+          " 百分比： " + progress.processedSize / progress.totalSize);
+      });
+      let options = {
+        "progressListener": progressListener,
+      }
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test022_first failed, with error message: " + err.message + ", error code: " + err.code);
+          expect().assertFail();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test022_first success. ");
+          expect(true).assertTrue();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test022_first failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+
+    try {
+      fs.copy(this.srcFileUriLocal, this.dstFileUriLocal, options, (err) => {
+        if (err) {
+          console.info(TAG, "Fs_Copy_Test022_second failed, with error message: " + err.message + ", error code: " + err.code);
+          expect(true).assertTrue();
+          done();
+        } else {
+          console.info(TAG, "Fs_Copy_Test022_second success. ");
+          expect().assertFail();
+        }
+      })
+    } catch (err) {
+      console.error("Fs_Copy_Test022_second failed with invalid param: " + err.message + ", error code: " + err.code);
+      expect().assertFail();
+      done();
+    }
+  });
+});
\ No newline at end of file
diff --git a/interfaces/test/unittest/napi_test/mode_fs_test/config.json b/interfaces/test/unittest/napi_test/mode_fs_test/config.json
new file mode 100644
index 0000000000000000000000000000000000000000..67e6569ac5f4b9393b58181f583d5f91c5913a39
--- /dev/null
+++ b/interfaces/test/unittest/napi_test/mode_fs_test/config.json
@@ -0,0 +1,62 @@
+{
+  "app": {
+    "bundleName": "com.example.myapplication",
+    "vendor": "example",
+    "version": {
+      "code": 1,
+      "name": "1.0"
+    },
+    "apiVersion": {
+      "compatible": 4,
+      "target": 5
+    }
+  },
+  "deviceConfig": {},
+  "module": {
+    "package": "com.example.myapplication",
+    "name": ".MyApplication",
+    "deviceType": [
+      "default",
+      "tablet",
+      "2in1"
+    ],
+    "distro": {
+      "deliveryWithInstall": true,
+      "moduleName": "entry",
+      "moduleType": "entry"
+    },
+    "abilities": [
+      {
+        "visible": true,
+        "skills": [
+          {
+            "entities": [
+              "entity.system.home"
+            ],
+            "actions": [
+              "action.system.home"
+            ]
+          }
+        ],
+        "name": "com.example.myapplication.MainAbility",
+        "icon": "$media:icon",
+        "description": "$string:mainability_description",
+        "label": "MyApplication",
+        "type": "page",
+        "launchType": "standard"
+      }
+    ],
+    "js": [
+      {
+        "pages": [
+          "pages/index/index"
+        ],
+        "name": "default",
+        "window": {
+          "designWidth": 720,
+          "autoDesignWidth": false
+        }
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/napi_test/mode_fs_test/openharmony_sx.p7b b/interfaces/test/unittest/napi_test/mode_fs_test/openharmony_sx.p7b
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391