1/*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import fs from '@ohos.file.fs';
17import fileuri from '@ohos.file.fileuri';
18
19import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
20
21const TAG = 'FsCopyTest';
22describe("FsCopyTest", function () {
23  let pathDir = '/data/storage/el2/base/haps/entry/files';
24  let srcDirPathLocal = pathDir + "/src";
25  let srcFilePathLocal = srcDirPathLocal + '/srcFile.txt';
26  let dstDirPathLocal = pathDir + "/dest";
27  let dstFilePathLocal = dstDirPathLocal + '/dstFile.txt';
28  let muiltDirLocal = srcDirPathLocal+"/test1";
29  let srcNoSuffixFileLocal = srcDirPathLocal + '/test';
30
31  let srcDirUriLocal = fileuri.getUriFromPath(srcDirPathLocal);
32  let srcFileUriLocal = fileuri.getUriFromPath(srcFilePathLocal);
33  let dstDirUriLocal = fileuri.getUriFromPath(dstDirPathLocal);
34  let dstFileUriLocal = fileuri.getUriFromPath(dstFilePathLocal);
35  let srcNoSuffixFileUriLocal = fileuri.getUriFromPath(srcNoSuffixFileLocal);
36
37  beforeAll(function () {
38    console.info(TAG, 'beforeAll called')
39  });
40
41  afterAll(function () {
42    console.info(TAG, 'afterAll called')
43  });
44
45  beforeEach(function () {
46    console.info(TAG, 'beforeEach called')
47  });
48
49  afterEach(function () {
50    console.info(TAG, 'afterEach called')
51  });
52
53  function isDirectory(path){
54    try {
55      console.info("Fs_Copy_Test020:path",path);
56      let stat = fs.statSync(path);
57      if (stat.isDirectory()) {
58        return true;
59      }
60      return false;
61    } catch (error) {
62      console.error("Error:", error);
63      return false;
64    }
65  }
66
67  /*
68   * @tc.name:Fs_Copy_Test001
69   * @tc.desc:test fs.copy with wrong params
70   * @tc.type: FUNC
71   * @tc.require: #I8UV2F
72   */
73  it("Fs_Copy_Test001", 0, async function (done) {
74    console.info(TAG, 'Fs_Copy_Test001 start.');
75    try {
76      await fs.copy("aaa", "bbb", (err) => {
77        if (err) {
78          console.info(TAG, "Fs_Copy_Test001 failed, with error message: " + err.message + ", error code: " + err.code);
79        } else {
80          console.info(TAG, "Fs_Copy_Test001 success. ");
81        }
82        expect().assertFail();
83        done();
84      })
85    } catch (err) {
86      console.error("Fs_Copy_Test001 failed with invalid param: " + err.message + ", error code: " + err.code);
87      expect(true).assertTrue();
88      done();
89    }
90  });
91
92  /*
93   * @tc.name:Fs_Copy_Test002
94   * @tc.desc:test fs.copy with sandbox path
95   * @tc.type: FUNC
96   * @tc.require: #I8UV2F
97   */
98  it("Fs_Copy_Test002", 0, async function (done) {
99    console.info(TAG, 'Fs_Copy_Test002 start.');
100    try {
101      await fs.copy(pathDir, "bbb", (err) => {
102        if (err) {
103          console.info(TAG, "Fs_Copy_Test002 failed, with error message: " + err.message + ", error code: " + err.code);
104        } else {
105          console.info(TAG, "Fs_Copy_Test002 success. ");
106        }
107        expect().assertFail();
108        done();
109      })
110    } catch (err) {
111      console.error("Fs_Copy_Test002 failed with invalid param: " + err.message + ", error code: " + err.code);
112      expect(true).assertTrue();
113      done();
114    }
115  });
116
117  /*
118   * @tc.name:Fs_Copy_Test003
119   * @tc.desc:test fs.copy with not exist dir
120   * @tc.type: FUNC
121   * @tc.require: #I8UV2F
122   */
123  it("Fs_Copy_Test003", 0, async function (done) {
124    console.info(TAG, 'Fs_Copy_Test003 start.');
125    try {
126      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
127        if (err) {
128          console.error(TAG, "Fs_Copy_Test003 failed: " + err.message + ", error code: " + err.code);
129          expect(true).assertTrue();
130        } else {
131          console.info(TAG, "Fs_Copy_Test003 success.");
132          expect().assertFail();
133        }
134        done();
135      })
136    } catch (err) {
137      console.error("Fs_Copy_Test003 failed with invalid param: " + err.message + ", error code: " + err.code);
138      expect(true).assertTrue();
139      done();
140    }
141  });
142
143  /*
144   * @tc.name:Fs_Copy_Test004
145   * @tc.desc:test fs.copy dir to itself
146   * @tc.type: FUNC
147   * @tc.require: #I8UV2F
148   */
149  it("Fs_Copy_Test004", 0, async function (done) {
150    console.info(TAG, 'Fs_Copy_Test004 start.');
151    try {
152      fs.mkdirSync(srcDirPathLocal);
153      fs.mkdirSync(dstDirPathLocal);
154      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
155        if (err) {
156          console.info(TAG, "Fs_Copy_Test004 failed, with error message: " + err.message + ", error code: " + err.code);
157          expect().assertFail();
158        } else {
159          console.info(TAG, "Fs_Copy_Test004 success. ");
160          expect(true).assertTrue();
161        }
162        done();
163      })
164    } catch (err) {
165      console.error("Fs_Copy_Test004 failed with invalid param: " + err.message + ", error code: " + err.code);
166      expect().assertFail();
167      done();
168    }
169  });
170
171  /*
172   * @tc.name:Fs_Copy_Test005
173   * @tc.desc:test fs.copy, copy file, src isn't exist
174   * @tc.type: FUNC
175   * @tc.require: #I8UV2F
176   */
177  it("Fs_Copy_Test005", 0, async function (done) {
178    console.info(TAG, 'Fs_Copy_Test005 start.');
179    try {
180      fs.rmdirSync(srcDirPathLocal);
181      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
182        if (err) {
183          console.info(TAG, "Fs_Copy_Test005 failed, with error message: " + err.message + ", error code: " + err.code);
184          expect(true).assertTrue();
185        } else {
186          console.info(TAG, "Fs_Copy_Test005 success. ");
187          expect(true).assertTrue();
188        }
189        done();
190      })
191    } catch (err) {
192      console.error("Fs_Copy_Test005 failed with invalid param: " + err.message + ", error code: " + err.code);
193      expect().assertFail();
194      done();
195    } finally {
196      fs.rmdirSync(dstDirPathLocal);
197    }
198  });
199
200  /*
201   * @tc.name:Fs_Copy_Test006
202   * @tc.desc:test fs.copy, copy file to file
203   * @tc.type: FUNC
204   * @tc.require: #I8UV2F
205   */
206  it("Fs_Copy_Test006", 0, async function (done) {
207    console.info(TAG, 'Fs_Copy_Test006 start.');
208    try {
209      fs.mkdirSync(srcDirPathLocal);
210      fs.mkdirSync(dstDirPathLocal);
211      let srcFile = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
212      fs.writeSync(srcFile.fd, 'ttttttttttttt');
213      fs.closeSync(srcFile);
214      let dstFile = fs.openSync(dstFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
215      fs.closeSync(dstFile);
216      await fs.copy(srcFileUriLocal, dstFileUriLocal, (err) => {
217        if (err) {
218          console.info(TAG, "Fs_Copy_Test006 failed, with error message: " + err.message + ", error code: " + err.code);
219          expect().assertFail();
220        } else {
221          console.info(TAG, "Fs_Copy_Test006 success. ");
222          expect(true).assertTrue();
223        }
224        done();
225      })
226    } catch (err) {
227      console.error("Fs_Copy_Test006 failed with invalid param: " + err.message + ", error code: " + err.code);
228      expect().assertFail();
229      done();
230    }
231  });
232
233  /*
234   * @tc.name:Fs_Copy_Test007
235   * @tc.desc:test fs.copy, copy file to dir
236   * @tc.type: FUNC
237   * @tc.require: #I8UV2F
238   */
239  it("Fs_Copy_Test007", 0, async function (done) {
240    console.info(TAG, 'Fs_Copy_Test007 start.');
241    try {
242      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
243      fs.writeSync(file.fd, 'ttttttttttttt');
244      fs.closeSync(file.fd);
245      await fs.copy(srcFileUriLocal, dstDirUriLocal, (err) => {
246        if (err) {
247          console.info(TAG, "Fs_Copy_Test007 failed, with error message: " + err.message + ", error code: " + err.code);
248          expect(true).assertTrue();
249        } else {
250          console.info(TAG, "Fs_Copy_Test007 success. ");
251          expect().assertFail();
252        }
253        done();
254      })
255    } catch (err) {
256      console.error("Fs_Copy_Test007 failed with invalid param: " + err.message + ", error code: " + err.code);
257      expect().assertFail();
258      done();
259    }
260  });
261
262  /*
263   * @tc.name:Fs_Copy_Test008
264   * @tc.desc:test fs.copy, copy dir to dir
265   * @tc.type: FUNC
266   * @tc.require: #I8UV2F
267   */
268  it("Fs_Copy_Test008", 0, async function (done) {
269    console.info(TAG, 'Fs_Copy_Test008 start.');
270    try {
271      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
272        if (err) {
273          console.info(TAG, "Fs_Copy_Test008 failed, with error message: " + err.message + ", error code: " + err.code);
274          expect().assertFail();
275        } else {
276          console.info(TAG, "Fs_Copy_Test008 success. ");
277          expect(true).assertTrue();
278        }
279        done();
280      })
281    } catch (err) {
282      console.error("Fs_Copy_Test008 failed with invalid param: " + err.message + ", error code: " + err.code);
283      expect().assertFail();
284      done();
285    } finally {
286      fs.rmdirSync(srcDirPathLocal);
287      fs.rmdirSync(dstDirPathLocal);
288    }
289  });
290
291  /*
292   * @tc.name:Fs_Copy_Test009
293   * @tc.desc:test fs.copy, copy file and write the contents but dest dir isn't exist
294   * @tc.type: FUNC
295   * @tc.require: #I8UV2F
296   */
297  it("Fs_Copy_Test009", 0, async function (done) {
298    console.info(TAG, 'Fs_Copy_Test009 start.');
299    try {
300      fs.mkdirSync(srcDirPathLocal);
301      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
302      fs.writeSync(file.fd, 'ttttttttttttt');
303      fs.closeSync(file);
304      await fs.copy(srcFileUriLocal, dstFileUriLocal, (err) => {
305        if (err) {
306          console.info(TAG, "Fs_Copy_Test009 failed, with error message: " + err.message + ", error code: " + err.code);
307          expect(true).assertTrue();
308        } else {
309          console.info(TAG, "Fs_Copy_Test009 success. ");
310          expect().assertFail();
311        }
312        done();
313      })
314    } catch (err) {
315      console.error("Fs_Copy_Test009 failed with invalid param: " + err.message + ", error code: " + err.code);
316      expect(true).assertTrue();
317      done();
318    } finally {
319      fs.rmdirSync(srcDirPathLocal);
320    }
321  });
322
323  /*
324   * @tc.name:Fs_Copy_Test010
325   * @tc.desc:test fs.copy, copy dir and file in the src path
326   * @tc.type: FUNC
327   * @tc.require: #I8UV2F
328   */
329  it("Fs_Copy_Test010", 0, async function (done) {
330    console.info(TAG, 'Fs_Copy_Test010 start.');
331    try {
332      fs.mkdirSync(srcDirPathLocal);
333      fs.mkdirSync(dstDirPathLocal);
334      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
335      fs.writeSync(file.fd, 'ttttttttttttt');
336      fs.closeSync(file);
337      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
338        if (err) {
339          console.info(TAG, "Fs_Copy_Test010 failed, with error message: " + err.message + ", error code: " + err.code);
340          expect().assertFail();
341        } else {
342          console.info(TAG, "Fs_Copy_Test010 success. ");
343          expect(true).assertTrue();
344        }
345        done();
346      })
347    } catch (err) {
348      console.error("Fs_Copy_Test010 failed with invalid param: " + err.message + ", error code: " + err.code);
349      expect().assertFail();
350      done();
351    }
352  });
353
354  /*
355   * @tc.name:Fs_Copy_Test011
356   * @tc.desc:test fs.copy, copy file to file with listener
357   * @tc.type: FUNC
358   * @tc.require: #I8UV2F
359   */
360  it("Fs_Copy_Test011", 0, async function (done) {
361    console.info(TAG, 'Fs_Copy_Test011 start.');
362    try {
363      let flag = false;
364      let progressListener = (progress) => {
365        flag = true;
366        console.info("Fs_Copy_Test011 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
367            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
368      };
369      let options = {
370        "progressListener": progressListener
371      }
372      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
373      fs.writeSync(file.fd, 'ttttttttttttt');
374      fs.closeSync(file);
375      await fs.copy(srcFileUriLocal, dstFileUriLocal, options, (err) => {
376        if (err) {
377          console.info(TAG, "Fs_Copy_Test011 failed, with error message: " + err.message + ", error code: " + err.code);
378          expect().assertFail();
379        } else {
380          console.info(TAG, "Fs_Copy_Test011 success. ");
381          expect(true).assertTrue();
382        }
383        done();
384      })
385      setTimeout(function () {
386        if (!flag) {
387          console.info(TAG, "Fs_Copy_Test013 progressListener error. ");
388          expect().assertFail();
389          done();
390          return;
391        }
392        expect(true).assertTrue();
393        done();
394      }, 100);
395    } catch (err) {
396      console.error("Fs_Copy_Test011 failed with invalid param: " + err.message + ", error code: " + err.code);
397      expect().assertFail();
398      done();
399    }
400  });
401
402  /*
403   * @tc.name:Fs_Copy_Test012
404   * @tc.desc:test fs.copy, copy dir to dir with listener
405   * @tc.type: FUNC
406   * @tc.require: #I8UV2F
407   */
408  it("Fs_Copy_Test012", 0, async function (done) {
409    console.info(TAG, 'Fs_Copy_Test012 start.');
410    try {
411      let flag = false;
412      let progressListener = (progress) => {
413        flag = true;
414        console.info("Fs_Copy_Test012 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
415            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
416      };
417      let options = {
418        "progressListener": progressListener
419      }
420      await fs.copy(srcDirUriLocal, dstDirUriLocal, options, (err) => {
421        if (err) {
422          console.info(TAG, "Fs_Copy_Test012 failed, with error message: " + err.message + ", error code: " + err.code);
423          expect().assertFail();
424        } else {
425          console.info(TAG, "Fs_Copy_Test012 success. ");
426        }
427      })
428      setTimeout(function () {
429        if (!flag) {
430          console.info(TAG, "Fs_Copy_Test013 progressListener error. ");
431          expect().assertFail();
432          done();
433          return;
434        }
435        expect(true).assertTrue();
436        done();
437      }, 100);
438    } catch (err) {
439      console.error("Fs_Copy_Test012 failed with invalid param: " + err.message + ", error code: " + err.code);
440      expect().assertFail();
441      done();
442    }
443  });
444
445  /*
446   * @tc.name:Fs_Copy_Test013
447   * @tc.desc:test fs.copy, copy file to file with listener promise
448   * @tc.type: FUNC
449   * @tc.require: #I8UV2F
450   */
451  it("Fs_Copy_Test013", 0, async function (done) {
452    console.info(TAG, 'Fs_Copy_Test013 start.');
453    try {
454      let flag = false;
455      let progressListener = (progress) => {
456        flag = true;
457        console.info("Fs_Copy_Test013 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
458            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
459      };
460      let options = {
461        "progressListener": progressListener
462      }
463      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
464      fs.writeSync(file.fd, 'ttttttttttttt');
465      fs.closeSync(file);
466      await fs.copy(srcFileUriLocal, dstFileUriLocal, options).then((err) => {
467        if (err) {
468          console.info(TAG, "Fs_Copy_Test013 failed, with error message: " + err.message + ", error code: " + err.code);
469          expect().assertFail();
470        } else {
471          console.info(TAG, "Fs_Copy_Test013 success. ");
472        }
473      })
474      setTimeout(function () {
475        if (!flag) {
476          console.info(TAG, "Fs_Copy_Test013 progressListener error. ");
477          expect().assertFail();
478          done();
479          return;
480        }
481        expect(true).assertTrue();
482        done();
483      }, 100);
484    } catch (err) {
485      console.error("Fs_Copy_Test013 failed with invalid param: " + err.message + ", error code: " + err.code);
486      expect().assertFail();
487      done();
488    }
489  });
490
491  /*
492   * @tc.name:Fs_Copy_Test014
493   * @tc.desc:test fs.copy, copy dir to dir with listener promise
494   * @tc.type: FUNC
495   * @tc.require: #I8UV2F
496   */
497  it("Fs_Copy_Test014", 0, async function (done) {
498    console.info(TAG, 'Fs_Copy_Test014 start.');
499    try {
500      let flag = false;
501      let progressListener = (progress) => {
502        flag = true;
503        console.info("Fs_Copy_Test014 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
504            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
505      };
506      let options = {
507        "progressListener": progressListener
508      }
509      await fs.copy(srcDirUriLocal, dstDirUriLocal, options).then((err) => {
510        if (err) {
511          console.info(TAG, "Fs_Copy_Test014 failed, with error message: " + err.message + ", error code: " + err.code);
512          expect().assertFail();
513          done();
514        } else {
515          console.info(TAG, "Fs_Copy_Test014 success. ");
516        }
517        setTimeout(function () {
518          if (!flag) {
519            console.info(TAG, "Fs_Copy_Test013 progressListener error. ");
520            expect().assertFail();
521            done();
522            return;
523          }
524          expect(true).assertTrue();
525          done();
526        }, 100);
527      })
528    } catch (err) {
529      console.error("Fs_Copy_Test014 failed with invalid param: " + err.message + ", error code: " + err.code);
530      expect().assertFail();
531      done();
532    }
533  });
534
535  /*
536   * @tc.name:Fs_Copy_Test015
537   * @tc.desc:test fs.copy, copy file 2 times
538   * @tc.type: FUNC
539   * @tc.require: #I8UV2F
540   */
541  it("Fs_Copy_Test015", 0, async function (done) {
542    console.info(TAG, 'Fs_Copy_Test015 start.');
543    try {
544      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
545      fs.writeSync(file.fd, 'ttttttttttttt');
546      fs.closeSync(file);
547      await fs.copy(srcFileUriLocal, dstFileUriLocal, (err) => {
548        if (err) {
549          console.info(TAG, "Fs_Copy_Test015_first failed, with error message: " + err.message + ", error code: " + err.code);
550          expect().assertFail();
551          done();
552        } else {
553          console.info(TAG, "Fs_Copy_Test015_first success. ");
554        }
555      })
556
557      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
558        if (err) {
559          console.info(TAG, "Fs_Copy_Test015_second failed, with error message: " + err.message + ", error code: " + err.code);
560          expect().assertFail();
561        } else {
562          console.info(TAG, "Fs_Copy_Test015_second success. ");
563          expect(true).assertTrue();
564          fs.rmdirSync(srcDirPathLocal);
565          fs.rmdirSync(dstDirPathLocal);
566        }
567        done();
568      })
569    } catch (err) {
570      console.error("Fs_Copy_Test015 failed with invalid param: " + err.message + ", error code: " + err.code);
571      expect().assertFail();
572      done();
573    }
574  });
575
576  /*
577   * @tc.name:Fs_Copy_Test016
578   * @tc.desc:test fs.copy, copy empty file
579   * @tc.type: FUNC
580   * @tc.require: #I8UV2F
581   */
582  it("Fs_Copy_Test016", 0, async function (done) {
583    console.info(TAG, 'Fs_Copy_Test016 start.');
584    try {
585      if (fs.accessSync(srcFilePathLocal)) {
586        fs.unlinkSync(srcFilePathLocal);
587      }
588      fs.mkdirSync(srcDirPathLocal);
589      fs.mkdirSync(dstDirPathLocal);
590      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
591      fs.closeSync(file);
592      await fs.copy(srcFileUriLocal, dstFileUriLocal, (err) => {
593        if (err) {
594          console.info(TAG, "Fs_Copy_Test016 failed, with error message: " + err.message + ", error code: " + err.code);
595          expect().assertFail();
596        } else {
597          console.info(TAG, "Fs_Copy_Test016 success. ");
598          expect(true).assertTrue();
599        }
600        done();
601      })
602    } catch (err) {
603      console.error("Fs_Copy_Test016 failed with invalid param: " + err.message + ", error code: " + err.code);
604      expect().assertFail();
605      done();
606    }
607  });
608
609  /*
610   * @tc.name:Fs_Copy_Test017
611   * @tc.desc:test fs.copy, copy empty dir
612   * @tc.type: FUNC
613   * @tc.require: #I8UV2F
614   */
615  it("Fs_Copy_Test017", 0, async function (done) {
616    console.info(TAG, 'Fs_Copy_Test017 start.');
617    try {
618      if (fs.accessSync(srcFilePathLocal)) {
619        fs.unlinkSync(srcFilePathLocal);
620      }
621      await fs.copy(srcDirUriLocal, dstDirUriLocal, (err) => {
622        if (err) {
623          console.info(TAG, "Fs_Copy_Test017 failed, with error message: " + err.message + ", error code: " + err.code);
624          expect().assertFail();
625        } else {
626          console.info(TAG, "Fs_Copy_Test017 success. ");
627          expect(true).assertTrue();
628        }
629        done();
630      })
631    } catch (err) {
632      console.error("Fs_Copy_Test017 failed with invalid param: " + err.message + ", error code: " + err.code);
633      expect().assertFail();
634      done();
635    }
636  });
637
638  /*
639   * @tc.name:Fs_Copy_Test018
640   * @tc.desc:test fs.copy, copy empty dir
641   * @tc.type: FUNC
642   * @tc.require: #I8UV2F
643   */
644  it("Fs_Copy_Test018", 0, async function (done) {
645    console.info(TAG, 'Fs_Copy_Test017 start.');
646    try {
647      let flag = false;
648      let progressListener = (progress) => {
649        flag = true;
650        console.info("Fs_Copy_Test018 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize);
651      };
652      let options = {
653        "progressListener": progressListener
654      }
655      if (fs.accessSync(srcFilePathLocal)) {
656        fs.unlinkSync(srcFilePathLocal);
657      }
658      await fs.copy(srcDirUriLocal, dstDirUriLocal, options, (err) => {
659        if (err) {
660          console.info(TAG, "Fs_Copy_Test018 failed, with error message: " + err.message + ", error code: " + err.code);
661          expect().assertFail();
662          done();
663        } else {
664          console.info(TAG, "Fs_Copy_Test018 success. ");
665        }
666      })
667      setTimeout(function () {
668        if (!flag) {
669          console.info(TAG, "Fs_Copy_Test013 progressListener error. ");
670          expect().assertFail();
671          done();
672          return;
673        }
674        expect(true).assertTrue();
675        done();
676      }, 100);
677    } catch (err) {
678      console.error("Fs_Copy_Test018 failed with invalid param: " + err.message + ", error code: " + err.code);
679      expect().assertFail();
680      done();
681    }
682  });
683
684  /*
685   * @tc.name:Fs_Copy_Test019
686   * @tc.desc:test fs.copy file to itself
687   * @tc.type: FUNC
688   * @tc.require: #I8UV2F
689   */
690  it("Fs_Copy_Test019", 0, async function (done) {
691    console.info(TAG, 'Fs_Copy_Test019 start.');
692    try {
693      await fs.copy(srcFileUriLocal, srcFileUriLocal, (err) => {
694        if (err) {
695          console.info(TAG, "Fs_Copy_Test019 failed, with error message: " + err.message + ", error code: " + err.code);
696          expect(true).assertTrue();
697        } else {
698          console.info(TAG, "Fs_Copy_Test019 success. ");
699          expect().assertFail();
700        }
701        done();
702      })
703    } catch (err) {
704      console.error("Fs_Copy_Test019 failed with invalid param: " + err.message + ", error code: " + err.code);
705      expect(false).assertTrue();
706      done();
707    }
708  });
709
710  /*
711    * @tc.name:Fs_Copy_Test020
712    * @tc.desc:test fs.copy, copy muilt empty dir
713    * @tc.type: FUNC
714    * @tc.require: #I8UV2F
715    */
716  it("Fs_Copy_Test020", 0, async function (done) {
717    console.info(TAG, 'Fs_Copy_Test020 start.');
718    try {
719      fs.mkdirSync(srcDirPathLocal+"/test1");
720      fs.mkdirSync(srcDirPathLocal+"/test2");
721      let progressListener = (progress) => {
722        console.info("Fs_Copy_Test020 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize);
723      };
724      let options = {
725        "progressListener": progressListener
726      }
727      await fs.copy(srcDirUriLocal, dstDirUriLocal, options, (err) => {
728        if (err) {
729          console.info(TAG, "Fs_Copy_Test020 failed, with error message: " + err.message + ", error code: " + err.code);
730          expect().assertFail();
731        } else {
732          if (isDirectory(dstDirPathLocal + "/src/test1") && isDirectory(dstDirPathLocal + "/src/test2")) {
733            console.info(TAG, "Fs_Copy_Test020 success. ");
734            expect(true).assertTrue();
735            done();
736            return;
737          }
738          expect().assertFail();
739        }
740        done();
741      })
742    } catch (err) {
743      console.error("Fs_Copy_Test020 failed with invalid param: " + err.message + ", error code: " + err.code);
744      expect().assertFail();
745      done();
746    }
747  });
748
749  /*
750  * @tc.name:Fs_Copy_Test021
751  * @tc.desc:test fs.copy, copy muilt dir contain files
752  * @tc.type: FUNC
753  * @tc.require: #I8UV2F
754  */
755  it("Fs_Copy_Test021", 0, async function (done) {
756    console.info(TAG, 'Fs_Copy_Test021 start.');
757    try {
758      let file1 = fs.openSync(muiltDirLocal + "/test1.txt", fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
759      fs.writeSync(file1.fd, "ttttttttttttt");
760      fs.closeSync(file1);
761      let file2 = fs.openSync(muiltDirLocal + "/test2.txt", fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
762      fs.writeSync(file2.fd, "ttttttttttttt");
763      fs.closeSync(file2);
764      let progressListener = (progress) => {
765        console.info("Fs_Copy_Test021 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
766            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
767      };
768      let options = {
769        "progressListener": progressListener
770      }
771      await fs.copy(srcDirUriLocal, dstDirUriLocal, options, (err) => {
772        if (err) {
773          console.info(TAG, "Fs_Copy_Test021 failed, with error message: " + err.message + ", error code: " + err.code);
774          expect().assertFail();
775        } else {
776          if (fs.accessSync(dstDirPathLocal +"/src/test1/test1.txt") && fs.accessSync(dstDirPathLocal + "/src/test1/test2.txt")) {
777            console.info(TAG, "Fs_Copy_Test021 success. ");
778            expect(true).assertTrue();
779            done();
780            return;
781          }
782          expect().assertFail();
783        }
784        done();
785      })
786    } catch (err) {
787      console.error("Fs_Copy_Test021 failed with invalid param: " + err.message + ", error code: " + err.code);
788      expect().assertFail();
789      done();
790    }
791  });
792
793  /*
794   * @tc.name:Fs_Copy_Test022
795   * @tc.desc:test fs.copy, copy file 10 times
796   * @tc.type: FUNC
797   * @tc.require: #I8UV2F
798   */
799  it("Fs_Copy_Test022", 0, async function (done) {
800    console.info(TAG, 'Fs_Copy_Test022 start.');
801    try {
802      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
803      fs.writeSync(file.fd, 'ttttttttttttt');
804      fs.closeSync(file);
805      // execute the copy operation 10 times
806      for (let i = 0; i < 10; i++) {
807        const dstStitchFilePath = `${dstDirUriLocal}/file_${i}.txt`;
808        await fs.copy(srcFileUriLocal, dstStitchFilePath, (err) => {
809          if (err) {
810            console.info(TAG, "Fs_Copy_Test022 failed, with error message: " + err.message + ", error code: " + err.code);
811            expect().assertFail();
812            done();
813          } else {
814            console.info(TAG, "Fs_Copy_Test022 success. ");
815          }
816        })
817      }
818      expect(true).assertTrue();
819      done();
820    } catch (err) {
821      console.error("Fs_Copy_Test022 failed with invalid param: " + err.message + ", error code: " + err.code);
822      expect().assertFail();
823      done();
824    }
825  });
826
827  /*
828   * @tc.name:Fs_Copy_Test023
829   * @tc.desc:test fs.copy, copy 1KB file
830   * @tc.type: FUNC
831   * @tc.require: #I8UV2F
832   */
833  it("Fs_Copy_Test023", 0, async function (done) {
834    console.info(TAG, 'Fs_Copy_Test023 start.');
835    try {
836      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
837      let content = 't'.repeat(1024);
838      fs.writeSync(file.fd, content);
839      fs.closeSync(file);
840      let progressListener = (progress) => {
841        console.info("Fs_Copy_Test023 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
842            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
843      };
844      let options = {
845        "progressListener": progressListener
846      }
847      await fs.copy(srcFileUriLocal, dstFileUriLocal, options, (err) => {
848        if (err) {
849          console.info(TAG, "Fs_Copy_Test023 failed, with error message: " + err.message + ", error code: " + err.code);
850          expect().assertFail();
851        } else {
852          console.info(TAG, "Fs_Copy_Test023 success. ");
853          expect(true).assertTrue();
854        }
855        done();
856      })
857    } catch (err) {
858      console.error("Fs_Copy_Test023 failed with invalid param: " + err.message + ", error code: " + err.code);
859      expect().assertFail();
860      done();
861    }
862  });
863
864  /*
865   * @tc.name:Fs_Copy_Test024
866   * @tc.desc:test fs.copy, copy 100MB file
867   * @tc.type: FUNC
868   * @tc.require: #I8UV2F
869   */
870  it("Fs_Copy_Test024", 0, async function (done) {
871    console.info(TAG, 'Fs_Copy_Test024 start.');
872    try {
873      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
874      let content = 't'.repeat(1024 * 1024 * 100);
875      fs.writeSync(file.fd, content);
876      fs.closeSync(file);
877      let progressListener = (progress) => {
878        console.info("Fs_Copy_Test024 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
879            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
880      };
881      let options = {
882        "progressListener": progressListener
883      }
884      await fs.copy(srcFileUriLocal, dstFileUriLocal, options, (err) => {
885        if (err) {
886          console.info(TAG, "Fs_Copy_Test024 failed, with error message: " + err.message + ", error code: " + err.code);
887          expect().assertFail();
888        } else {
889          console.info(TAG, "Fs_Copy_Test024 success. ");
890          expect(true).assertTrue();
891        }
892        done();
893      })
894    } catch (err) {
895      console.error("Fs_Copy_Test024 failed with invalid param: " + err.message + ", error code: " + err.code);
896      expect().assertFail();
897      done();
898    }
899  });
900
901  /*
902   * @tc.name:Fs_Copy_Test025
903   * @tc.desc:test fs.copy dir to own directory1
904   * @tc.type: FUNC
905   * @tc.require: #I8UV2F
906   */
907  it("Fs_Copy_Test025", 0, async function (done) {
908    console.info(TAG, 'Fs_Copy_Test025 start.');
909    try {
910      await fs.copy(srcDirUriLocal, srcDirUriLocal+"/", (err) => {
911        if (err) {
912          console.info(TAG, "Fs_Copy_Test025 failed, with error message: " + err.message + ", error code: " + err.code);
913          expect(true).assertTrue();
914        } else {
915          console.info(TAG, "Fs_Copy_Test025 success. ");
916          expect().assertFail();
917        }
918        done();
919      })
920    } catch (err) {
921      console.error("Fs_Copy_Test025 failed with invalid param: " + err.message + ", error code: " + err.code);
922      expect().assertFail();
923      done();
924    }
925  });
926
927  /*
928   * @tc.name:Fs_Copy_Test026
929   * @tc.desc:test fs.copy dir to own directory2
930   * @tc.type: FUNC
931   * @tc.require: #I8UV2F
932   */
933  it("Fs_Copy_Test026", 0, async function (done) {
934    console.info(TAG, 'Fs_Copy_Test026 start.');
935    try {
936      await fs.copy(srcDirUriLocal+"/", srcDirUriLocal, (err) => {
937        if (err) {
938          console.info(TAG, "Fs_Copy_Test026 failed, with error message: " + err.message + ", error code: " + err.code);
939          expect(true).assertTrue();
940        } else {
941          console.info(TAG, "Fs_Copy_Test026 success. ");
942          expect().assertFail();
943        }
944        done();
945      })
946    } catch (err) {
947      console.error("Fs_Copy_Test026 failed with invalid param: " + err.message + ", error code: " + err.code);
948      expect().assertFail();
949      done();
950    }
951  });
952
953  /*
954   * @tc.name:Fs_Copy_Test027
955   * @tc.desc:test fs.copy file wiht no suffix
956   * @tc.type: FUNC
957   * @tc.require: #I8UV2F
958   */
959  it("Fs_Copy_Test027", 0, async function (done) {
960    console.info(TAG, 'Fs_Copy_Test027 start.');
961    try {
962      let file = fs.openSync(srcNoSuffixFileLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
963      fs.writeSync(file.fd, "ttttttttttttt");
964      fs.closeSync(file);
965      await fs.copy(srcNoSuffixFileUriLocal, dstDirUriLocal, (err) => {
966        if (err) {
967          console.info(TAG, "Fs_Copy_Test027 failed, with error message: " + err.message + ", error code: " + err.code);
968          expect(true).assertTrue();
969        } else {
970          console.info(TAG, "Fs_Copy_Test027 success. ");
971          expect().assertFail();
972        }
973        done();
974      })
975    } catch (err) {
976      console.error("Fs_Copy_Test027 failed with invalid param: " + err.message + ", error code: " + err.code);
977      expect().assertFail();
978      done();
979    }
980  });
981  /*
982   * @tc.name:Fs_Copy_Test028
983   * @tc.desc:test fs.copy file with indiscriminate parameter
984   * @tc.type: FUNC
985   * @tc.require: #I8UV2F
986   */
987  it("Fs_Copy_Test028", 0, async function (done) {
988    console.info(TAG, 'Fs_Copy_Test028 start.');
989    try {
990      let srcPath = pathDir+"/./pppppp";
991      let destPath =pathDir+ "/ttt/pppppp";
992      let srcUriPath = fileuri.getUriFromPath(srcPath);
993      let destUriPath = fileuri.getUriFromPath(destPath);
994      fs.mkdirSync(srcPath);
995      await fs.copy(srcUriPath, destUriPath, (err) => {
996        if (err) {
997          console.info(TAG, "Fs_Copy_Test028 failed, with error message: " + err.message + ", error code: " + err.code);
998          expect(true).assertTrue();
999        } else {
1000          console.info(TAG, "Fs_Copy_Test028 success. ");
1001          expect().assertFail();
1002        }
1003        done();
1004      })
1005    } catch (err) {
1006      console.error("Fs_Copy_Test028 failed with invalid param: " + err.message + ", error code: " + err.code);
1007      expect().assertFail();
1008      done();
1009    }
1010  });
1011
1012  /*
1013   * @tc.name:Fs_Copy_Test029
1014   * @tc.desc:test fs.copy file with indiscriminate parameter2
1015   * @tc.type: FUNC
1016   * @tc.require: #I8UV2F
1017   */
1018  it("Fs_Copy_Test029", 0, async function (done) {
1019    console.info(TAG, 'Fs_Copy_Test029 start.');
1020    try {
1021      let srcPath = pathDir+"/.////ssssss///";
1022      let destPath =pathDir+ "/ttt/ssssss//////";
1023      let srcUriPath = fileuri.getUriFromPath(srcPath);
1024      let destUriPath = fileuri.getUriFromPath(destPath);
1025      fs.mkdirSync(srcPath);
1026      await fs.copy(srcUriPath, destUriPath, (err) => {
1027        if (err) {
1028          console.info(TAG, "Fs_Copy_Test029 failed, with error message: " + err.message + ", error code: " + err.code);
1029          expect(true).assertTrue();
1030        } else {
1031          console.info(TAG, "Fs_Copy_Test029 success. ");
1032          expect().assertFail();
1033        }
1034        done();
1035      })
1036    } catch (err) {
1037      console.error("Fs_Copy_Test029 failed with invalid param: " + err.message + ", error code: " + err.code);
1038      expect().assertFail();
1039      done();
1040    }
1041  });
1042
1043  /*
1044  * @tc.name:Fs_Copy_Test030
1045  * @tc.desc:test fs.copy dir to subdir
1046  * @tc.type: FUNC
1047  * @tc.require: #I8UV2F
1048  */
1049  it("Fs_Copy_Test030", 0, async function (done) {
1050    console.info(TAG, 'Fs_Copy_Test030 start.');
1051    try {
1052      let srcPath = pathDir+"/test1/";
1053      let destPath =pathDir+ "/test1/testttt2";
1054      let srcUriPath = fileuri.getUriFromPath(srcPath);
1055      let destUriPath = fileuri.getUriFromPath(destPath);
1056      fs.mkdirSync(srcPath);
1057      await fs.copy(srcUriPath, destUriPath, (err) => {
1058        if (err) {
1059          console.info(TAG, "Fs_Copy_Test030 failed, with error message: " + err.message + ", error code: " + err.code);
1060          expect(true).assertTrue();
1061        } else {
1062          console.info(TAG, "Fs_Copy_Test030 success. ");
1063          expect().assertFail();
1064        }
1065        done();
1066      })
1067    } catch (err) {
1068      console.error("Fs_Copy_Test030 failed with invalid param: " + err.message + ", error code: " + err.code);
1069      expect().assertFail();
1070      done();
1071    }
1072  });
1073
1074  /*
1075   * @tc.name:Fs_Copy_Test031
1076   * @tc.desc:test fs.copy, same task
1077   * @tc.type: FUNC
1078   * @tc.require: #I8UV2F
1079   */
1080  it("Fs_Copy_Test031", 0, async function (done) {
1081    console.info(TAG, 'Fs_Copy_Test031 start.');
1082    try {
1083      let flag1 = false;
1084      let flag2 = false;
1085      let progressListener = (progress) => {
1086        console.info("Fs_Copy_Test031 progressListener in, progressSize: " + progress.processedSize + ", totalSize: " + progress.totalSize +
1087            " progress： " + (progress.processedSize / progress.totalSize * 100).toFixed(2) + "%");
1088      };
1089      let options = {
1090        "progressListener": progressListener
1091      }
1092      if (fs.accessSync(srcFilePathLocal)) {
1093        fs.unlinkSync(srcFilePathLocal);
1094      }
1095      let file = fs.openSync(srcFilePathLocal, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
1096      fs.writeSync(file.fd, 'ttttttttttttt');
1097      fs.closeSync(file);
1098      const task1 = new Promise(resolve => {
1099        setTimeout(() => {
1100          fs.copy(srcFileUriLocal, dstFileUriLocal, options, (err) => {
1101            if (err) {
1102              console.info(TAG, "Fs_Copy_Test031_first failed, with error message: " + err.message + ", error code: " + err.code);
1103              expect().assertFail();
1104            } else {
1105              flag1 = true;
1106              console.info(TAG, "Fs_Copy_Test031_first success. ");
1107            }
1108          })
1109          resolve();
1110        }, 10);
1111      });
1112
1113      const task2 = new Promise(resolve => {
1114        setTimeout(() => {
1115          try {
1116            fs.copy(srcFileUriLocal, dstFileUriLocal, options, (err) => {
1117              flag2 = true;
1118              if (err) {
1119                console.info(TAG, "Fs_Copy_Test031_second failed, with error message: " + err.message + ", error code: " + err.code);
1120              } else {
1121                console.info(TAG, "Fs_Copy_Test031_second success. ");;
1122              }
1123              expect().assertFail();
1124            })
1125            resolve();
1126          } catch (err) {
1127            console.error("Fs_Copy_Test031_second failed with invalid param: " + err.message + ", error code: " + err.code);
1128          }
1129        }, 20);
1130      });
1131      //the same task isn't execute
1132      Promise.all([task1, task2]).then(() => {
1133        if (flag1 && !flag2) {
1134          expect(true).assertTrue();
1135          done();
1136        }
1137      });
1138      done();
1139    } catch (err) {
1140      console.error("Fs_Copy_Test031 failed with invalid param: " + err.message + ", error code: " + err.code);
1141      expect().assertFail();
1142      done();
1143    } finally {
1144      const timerId = setTimeout(() => {
1145        fs.rmdirSync(srcDirPathLocal);
1146        fs.rmdirSync(dstDirPathLocal);
1147        clearTimeout(timerId);
1148      }, 1000);
1149    }
1150  });
1151});