1/* 2 * Copyright (C) 2021 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 fileio from '@ohos.fileio'; 17import file from '@system.file'; 18import document from '@ohos.document'; 19import { 20 describe, 21 it, 22 expect 23} 24from '@ohos/hypium' 25import { 26 FILE_CONTENT, 27 prepareFile, 28 fileName, 29 randomString, 30 cacheFileName, 31 prepareEmptyFile, 32 nextFileName, 33 sleep 34} 35from './Common' 36 37export default function fileTest() { 38describe('fileTest', function () { 39 40 /** 41 * @tc.number SUB_STORAGE_File_Delete_0100 42 * @tc.name File_Delete_001 43 * @tc.desc Function of API, delete file.The test file is exist. 44 */ 45 it('File_Delete_001', 0, async function (done) { 46 let fpath = await fileName('File_Delete_001'); 47 expect(prepareFile(fpath, 'hello')).assertTrue(); 48 file.delete({ 49 uri: 'internal://cache/../files/File_Delete_001', 50 success: function () { 51 console.info('File_Delete_001 call delete success'); 52 done(); 53 }, 54 fail: function (data, code) { 55 console.info('File_Delete_001 call delete fail, code: ' + code + ', data: ' + data); 56 expect(null).assertFail(); 57 done(); 58 }, 59 }); 60 }); 61 62 /** 63 * @tc.number SUB_STORAGE_File_Delete_0200 64 * @tc.name File_Delete_002 65 * @tc.desc Function of API, delete dir.The dir is empty. 66 */ 67 it('File_Delete_002', 0, async function (done) { 68 file.mkdir({ 69 uri: 'internal://cache/File_Delete_002', 70 success: function () { 71 console.info('File_Delete_002 call mkdir success.'); 72 file.delete({ 73 uri: 'internal://cache/File_Delete_002', 74 success: function () { 75 console.info('File_Delete_002 call delete success.'); 76 done(); 77 }, 78 fail: function (data, code) { 79 console.info('File_Delete_002 call delete fail, code: ' + code + ', data: ' + data); 80 expect(null).assertFail(); 81 }, 82 }); 83 }, 84 fail: function (data, code) { 85 console.info('File_Delete_002 call mkdir fail, code: ' + code + ', data: ' + data); 86 expect(null).assertFail(); 87 }, 88 }); 89 }); 90 91 /** 92 * @tc.number SUB_STORAGE_File_Delete_0300 93 * @tc.name File_Delete_003 94 * @tc.desc Function of API, error code: 202 The test file or dir are exist. 95 */ 96 it('File_Delete_003', 0, async function (done) { 97 file.delete({ 98 uri: 'internal://ohos/workspace/text.txt', 99 success: function () { 100 console.info('File_Delete_003 call delete success.'); 101 expect(null).assertFail(); 102 }, 103 fail: function (data, code) { 104 console.info('File_Delete_003 call delete fail, code: ' + code + ', data: ' + data); 105 expect(code == 202).assertTrue(); 106 done(); 107 }, 108 }); 109 110 }); 111 112 /** 113 * @tc.number SUB_STORAGE_File_Delete_0400 114 * @tc.name File_Delete_004 115 * @tc.desc Function of API, error code: 300 The dir is exist with files. 116 */ 117 it('File_Delete_004', 0, async function (done) { 118 let dpath = await fileName('File_Delete_004'); 119 let fpath = dpath + '/File_Delete_004'; 120 fileio.mkdirSync(dpath); 121 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 122 file.delete({ 123 uri: 'internal://app/File_Delete_004', 124 success: function () { 125 console.info('File_Delete_004 call delete success.'); 126 expect(null).assertFail(); 127 }, 128 fail: function (data, code) { 129 console.info('File_Delete_004 call delete fail, code: ' + code + ', data: ' + data); 130 expect(code == 300).assertTrue(); 131 done(); 132 }, 133 }); 134 }); 135 136 /** 137 * @tc.number SUB_STORAGE_File_Delete_0500 138 * @tc.name File_Delete_005 139 * @tc.desc Function of API, error code: 301 The file and dir are not exist. 140 */ 141 it('File_Delete_005', 0, async function (done) { 142 file.delete({ 143 uri: 'internal://app/File_Delete_005', 144 success: function () { 145 console.info('File_Delete_005 call delete success.'); 146 expect(null).assertFail(); 147 }, 148 fail: function (data, code) { 149 console.info('File_Delete_005 call delete fail, code: ' + code + ', data: ' + data); 150 expect(code == 301).assertTrue(); 151 done(); 152 }, 153 }); 154 }); 155 156 /** 157 * @tc.number SUB_STORAGE_File_Delete_0600 158 * @tc.name File_Delete_006 159 * @tc.desc uri address length more than 4096 The test file is exist. 160 */ 161 it('File_Delete_006', 0, async function (done) { 162 let firstPath = randomString(32); 163 let dpath = await fileName(firstPath); 164 let uri = 'internal://cache/' + firstPath; 165 fileio.mkdirSync(dpath); 166 for (let i = 0; i < 16; i++) { 167 console.info('frequency' + i); 168 let sonPath = randomString(251); 169 uri = uri + '/f' + sonPath; 170 } 171 file.delete({ 172 uri: uri, 173 success: function () { 174 console.info('File_Delete_006 call delete success'); 175 expect(null).assertFail(); 176 }, 177 fail: function (data, code) { 178 console.info('File_Delete_006 call delete fail, code: ' + code + ', data: ' + data); 179 expect(code == 300).assertTrue(); 180 done(); 181 }, 182 }); 183 }); 184 185 /** 186 * @tc.number SUB_STORAGE_File_Delete_0700 187 * @tc.name File_Delete_007 188 * @tc.desc Function of API, delete file from cache.The test file on cache. 189 */ 190 it('File_Delete_007', 0, async function (done) { 191 file.writeText({ 192 uri: 'internal://cache/File_Delete_007', 193 text: 'test', 194 success: function () { 195 console.info('File_Delete_007 call writeText success'); 196 file.delete({ 197 uri: 'internal://cache/File_Delete_007', 198 success: function () { 199 console.info('File_Delete_007 call delete success'); 200 done(); 201 }, 202 fail: function (data, code) { 203 console.info('File_Delete_007 call delete fail, code: ' + code + ', data: ' + data); 204 expect(null).assertFail(); 205 }, 206 }); 207 }, 208 fail: function (data, code) { 209 console.info('File_Delete_007 call writeText fail, code: ' + code + ', data: ' + data); 210 expect(null).assertFail(); 211 }, 212 }); 213 }); 214 215 /** 216 * @tc.number SUB_STORAGE_File_Delete_0800 217 * @tc.name File_Delete_008. 218 * @tc.desc Function of API, delete file from Virtual path.The test file is exist. 219 */ 220 it('File_Delete_008', 0, async function (done) { 221 file.writeText({ 222 uri: 'internal://cache/../cache/File_Delete_008', 223 text: 'Text that just for test.', 224 success: function () { 225 console.info('File_Delete_008 call writeText success'); 226 file.delete({ 227 uri: 'internal://cache/../cache/File_Delete_008', 228 success: function () { 229 console.info('File_Delete_008 call delete success'); 230 done(); 231 }, 232 fail: function (data, code) { 233 console.info('File_Delete_008 call delete fail, code: ' + code + ', data: ' + data); 234 expect(null).assertFail(); 235 }, 236 complete: function () { 237 console.info('delete completed'); 238 } 239 }); 240 }, 241 fail: function (data, code) { 242 console.info('File_Delete_008 call writeText fail, code: ' + code + ', data: ' + data); 243 expect(null).assertFail(); 244 }, 245 }); 246 }); 247 248 /** 249 * @tc.number SUB_STORAGE_File_writeText_0100 250 * @tc.name File_writeText_001 251 * @tc.desc Function of API, write to file(app path).The test file is not exist. 252 */ 253 it('File_writeText_001', 0, async function (done) { 254 file.writeText({ 255 uri: 'internal://cache/File_writeText_001', 256 text: 'sawyerwang.', 257 success: function () { 258 console.info('File_writeText_001 call writeText success'); 259 file.readText({ 260 uri: 'internal://cache/File_writeText_001', 261 success: function (data) { 262 console.info('File_writeText_001 call read success. Content: ' ); 263 file.delete({ 264 uri: 'internal://cache/File_writeText_001', 265 success: function () { 266 console.info('File_writeText_001 call delete success'); 267 done(); 268 }, 269 fail: function (data, code) { 270 console.info('File_writeText_001 call delete fail, code: ' + code + ', data: ' + data); 271 expect(null).assertFail(); 272 }, 273 }); 274 }, 275 fail: function (data, code) { 276 console.info('File_writeText_001 call read fail , code: ' + code + ', data: ' + data); 277 expect(null).assertFail(); 278 }, 279 }); 280 }, 281 fail: function (data, code) { 282 console.info('File_writeText_001 call writeText fail , code: ' + code + ', data: ' + data); 283 expect(null).assertFail(); 284 }, 285 }); 286 }); 287 288 /** 289 * @tc.number SUB_STORAGE_File_writeText_0200 290 * @tc.name File_writeText_002 291 * @tc.desc Function of API, write to file.The test file is exist, it can be edited. 292 */ 293 it('File_writeText_002', 0, async function (done) { 294 file.writeText({ 295 uri: 'internal://cache/File_writeText_002', 296 text: 'Text1.', 297 success: function () { 298 console.info('File_writeText_002 call writeText success.'); 299 file.writeText({ 300 uri: 'internal://cache/File_writeText_002', 301 text: 'Text2.', 302 append: true, 303 success: function () { 304 console.info('File_writeText_002 call writeText success.'); 305 file.readText({ 306 uri: 'internal://cache/File_writeText_002', 307 success: function (data) { 308 console.info('File_writeText_002 call read success. Content: ' ); 309 file.delete({ 310 uri: 'internal://cache/File_writeText_002', 311 success: function () { 312 console.info('File_writeText_002 call delete success'); 313 done(); 314 }, 315 fail: function (data, code) { 316 console.info('File_writeText_002 call delete fail, code: ' + code + ', data: ' + data); 317 expect(null).assertFail(); 318 }, 319 }); 320 }, 321 fail: function (data, code) { 322 console.info('File_writeText_002 call read fail, code: ' + code + ', data: ' + data); 323 expect(null).assertFail(); 324 }, 325 }); 326 }, 327 fail: function (data, code) { 328 console.info('File_writeText_002 call writeText fail, code: ' + code + ', data: ' + data); 329 expect(null).assertFail(); 330 }, 331 }); 332 }, 333 fail: function (data, code) { 334 console.info('File_writeText_002 call writeText fail, code: ' + code + ', data: ' + data); 335 expect(null).assertFail(); 336 }, 337 }); 338 }); 339 340 /** 341 * @tc.number SUB_STORAGE_File_writeText_0300 342 * @tc.name File_writeText_003 343 * @tc.desc Different types of strings for text. 344 */ 345 it('File_writeText_003', 0, async function (done) { 346 let txt = 'hello 你好 ????? こんにちは ?????.' 347 file.writeText({ 348 uri: 'internal://cache/File_writeText_003', 349 text: txt, 350 success: function () { 351 console.info('File_writeText_003 call writeText success.'); 352 file.readText({ 353 uri: 'internal://cache/File_writeText_003', 354 success: function (data) { 355 console.info('File_writeText_003 call read success. Content: ' ); 356 file.delete({ 357 uri: 'internal://cache/File_writeText_003', 358 success: function () { 359 console.info('File_writeText_003 call delete success'); 360 done(); 361 }, 362 fail: function (data, code) { 363 console.info('File_writeText_003 call delete fail, code: ' + code + ', data: ' + data); 364 expect(null).assertFail(); 365 }, 366 }); 367 }, 368 fail: function (data, code) { 369 console.info('File_writeText_003 call read fail, code: ' + code + ', data: ' + data); 370 expect(null).assertFail(); 371 }, 372 }); 373 }, 374 fail: function (data, code) { 375 console.info('File_writeText_003 call writeText fail, code: ' + code + ', data: ' + data); 376 expect(null).assertFail(); 377 }, 378 }); 379 }); 380 381 /** 382 * @tc.number SUB_STORAGE_File_writeText_0400 383 * @tc.name File_writeText_004 384 * @tc.desc Defferent encoding(UTF-8). 385 */ 386 it('File_writeText_004', 0, async function (done) { 387 file.writeText({ 388 uri: 'internal://cache/File_writeText_004', 389 text: 'hello', 390 encoding: 'UTF-8', 391 success: function () { 392 console.info('File_writeText_004 call writeText success.'); 393 file.readText({ 394 uri: 'internal://cache/File_writeText_004', 395 encoding: 'UTF-8', 396 success: function (data) { 397 console.info('File_writeText_004 call readText success. Content: ' ); 398 file.delete({ 399 uri: 'internal://cache/File_writeText_004', 400 success: function () { 401 console.info('File_writeText_004 delete success'); 402 done(); 403 }, 404 fail: function (data, code) { 405 console.info('File_writeText_004 delete fail, code: ' + code + ', data: ' + data); 406 expect(null).assertFail(); 407 }, 408 }); 409 }, 410 fail: function (data, code) { 411 console.info('File_writeText_004 call readText fail, code: ' + code + ', data: ' + data); 412 expect(null).assertFail(); 413 }, 414 }); 415 }, 416 fail: function (data, code) { 417 console.info('File_writeText_004 call writeText fail, code: ' + code + ', data: ' + data); 418 expect(null).assertFail(); 419 }, 420 }); 421 }); 422 423 /** 424 * @tc.number SUB_STORAGE_File_writeText_0500 425 * @tc.name File_writeText_005 426 * @tc.desc Function of API, append mode.The test file is exist and it can be edited. 427 */ 428 it('File_writeText_005', 0, async function (done) { 429 file.writeText({ 430 uri: 'internal://cache/File_writeText_005', 431 text: 'hello,world', 432 success: function () { 433 console.info('File_writeText_005 call writeText success.'); 434 file.writeText({ 435 uri: 'internal://cache/File_writeText_005', 436 text: 'hello', 437 append: true, 438 success: function () { 439 console.info('File_writeText_005 call writeText success.'); 440 file.readText({ 441 uri: 'internal://cache/File_writeText_005', 442 success: function (data) { 443 console.info('File_writeText_005 call read success ' ); 444 file.delete({ 445 uri: 'internal://cache/File_writeText_005', 446 success: function () { 447 console.info('File_writeText_005 call delete success'); 448 done(); 449 }, 450 fail: function (data, code) { 451 console.info('File_writeText_005 call delete fail, code: ' + code + ', data: ' + data); 452 expect(null).assertFail(); 453 }, 454 }); 455 }, 456 fail: function (data, code) { 457 console.info('File_writeText_005 call readText fail , code: ' + code + ', data: ' + data); 458 expect(null).assertFail(); 459 }, 460 }); 461 }, 462 fail: function (data, code) { 463 console.info('File_writeText_005 call writeText fail, code: ' + code + ', data: ' + data); 464 expect(null).assertFail(); 465 }, 466 }); 467 }, 468 fail: function (data, code) { 469 console.info('File_writeText_005 call writeText fail, code: ' + code + ', data: ' + data); 470 expect(null).assertFail(); 471 }, 472 }); 473 }); 474 475 /** 476 * @tc.number SUB_STORAGE_File_writeText_0600 477 * @tc.name File_writeText_006 478 * @tc.desc Function of API, non-append mode.The test file is exist and it can be edited. 479 */ 480 it('File_writeText_006', 0, async function (done) { 481 file.writeText({ 482 uri: 'internal://cache/File_writeText_006', 483 text: 'hello', 484 success: function () { 485 console.info('File_writeText_006 call writeText success.'); 486 file.readText({ 487 uri: 'internal://cache/File_writeText_006', 488 success: function (data) { 489 console.info('File_writeText_006 call read success ' ); 490 file.delete({ 491 uri: 'internal://cache/File_writeText_006', 492 success: function () { 493 console.info('File_writeText_006 delete success'); 494 done(); 495 }, 496 fail: function (data, code) { 497 console.info('File_writeText_006 delete fail, code: ' + code + ', data: ' + data); 498 expect(null).assertFail(); 499 }, 500 }); 501 }, 502 fail: function (data, code) { 503 console.info('File_writeText_006 call readText fail, code: ' + code + ', data: ' + data); 504 expect(null).assertFail(); 505 }, 506 }); 507 }, 508 fail: function (data, code) { 509 console.info('File_writeText_006 call writeText fail, code: ' + code + ', data: ' + data); 510 expect(null).assertFail(); 511 }, 512 }); 513 }); 514 515 /** 516 * @tc.number SUB_STORAGE_File_writeText_0700 517 * @tc.name File_writeText_007 518 * @tc.desc Function of API, error code: 202 The test file and dir are exist. 519 */ 520 it('File_writeText_007', 0, async function (done) { 521 file.writeText({ 522 uri: '/data/accounts/account_0/appdata', 523 text: 'hello', 524 success: function () { 525 console.info('File_writeText_007 call writeText success.'); 526 expect(null).assertFail(); 527 }, 528 fail: function (data, code) { 529 console.info('File_writeText_007, code: ' + code + ', data: ' + data); 530 expect(code == 202).assertTrue(); 531 done(); 532 }, 533 }); 534 }); 535 536 /** 537 * @tc.number SUB_STORAGE_File_writeText_0800 538 * @tc.name File_writeText_008 539 * @tc.desc Function of API, error code: 300 The uri path is dir path. 540 */ 541 it('File_writeText_008', 0, async function (done) { 542 let dpath = await nextFileName('File_writeText_008d'); 543 fileio.mkdirSync(dpath); 544 file.writeText({ 545 uri: 'internal://cache/File_writeText_008d/', 546 text: 'hello', 547 success: function () { 548 console.info('File_writeText_008 call writeText success.'); 549 expect(null).assertFail(); 550 }, 551 fail: function (data, code) { 552 console.info('File_writeText_008 , code: ' + code + ', data: ' + data); 553 expect(code == 300).assertTrue(); 554 done(); 555 }, 556 }); 557 }); 558 559 /** 560 * @tc.number SUB_STORAGE_File_writeText_0900 561 * @tc.name File_writeText_009 562 * @tc.desc Function of API, error code: 300.The file path is not exist. 563 */ 564 it('File_writeText_009', 0, async function (done) { 565 file.writeText({ 566 uri: 'internal://app/File_writeText_009d/File_writeText_009', 567 text: 'test', 568 success: function () { 569 console.info('File_writeText_009 call writeText success.'); 570 expect(null).assertFail(); 571 }, 572 fail: function (data, code) { 573 console.info('File_writeText_009 , code: ' + code + ', data: ' + data); 574 expect(code == 300).assertTrue(); 575 done(); 576 }, 577 }); 578 }); 579 580 /** 581 * @tc.number SUB_STORAGE_File_writeText_1000 582 * @tc.name File_writeText_010 583 * @tc.desc Function of API, write to file(cache path).The test file is not exist. 584 */ 585 it('File_writeText_010', 0, async function (done) { 586 file.writeText({ 587 uri: 'internal://cache/File_writeText_010', 588 text: 'test', 589 success: function () { 590 console.info('File_writeText_010 mkdir success'); 591 file.delete({ 592 uri: 'internal://cache/File_writeText_010', 593 success: function () { 594 console.info('File_writeText_010 delete success'); 595 done(); 596 }, 597 fail: function (data, code) { 598 console.info('File_writeText_010 delete fail, code: ' + code + ', data: ' + data); 599 expect(null).assertFail(); 600 }, 601 }); 602 }, 603 fail: function (data, code) { 604 console.info('File_writeText_010 writeText fail, code: ' + code + ', data: ' + data); 605 expect(null).assertFail(); 606 }, 607 }); 608 }); 609 610 /** 611 * @tc.number SUB_STORAGE_File_writeText_1100 612 * @tc.name File_writeText_011 613 * @tc.desc Function of API, Virtual path.The test file is exist. 614 */ 615 it('File_writeText_011', 0, async function (done) { 616 file.writeText({ 617 uri: 'internal://cache/../cache/File_writeText_011', 618 text: 'sawyerwang', 619 success: function () { 620 console.info('File_writeText_011 writeText success '); 621 file.readText({ 622 uri: 'internal://cache/../cache/File_writeText_011', 623 success: function (data) { 624 console.info('File_writeText_011 readText success ' ); 625 file.delete({ 626 uri: 'internal://cache/../cache/File_writeText_011', 627 success: function () { 628 console.info('File_writeText_011 delete success'); 629 done(); 630 }, 631 fail: function (data, code) { 632 console.info('File_writeText_011 delete fail, code: ' + code + ', data: ' + data); 633 expect(null).assertFail(); 634 }, 635 }); 636 }, 637 fail: function (data, code) { 638 console.info('File_writeText_011 readText fail, code: ' + code + ', data: ' + data); 639 expect(null).assertFail(); 640 }, 641 }); 642 }, 643 fail: function (data, code) { 644 console.info('File_writeText_011 writeText fail, code: ' + code + ', data: ' + data); 645 expect(null).assertFail(); 646 }, 647 }); 648 }); 649 650 /** 651 * @tc.number SUB_STORAGE_File_writeText_1300 652 * @tc.name File_writeText_013 653 * @tc.desc Function of API, write file out of package, Virtual path, save the dir authority.The test file is exist. 654 */ 655 it('File_writeText_013', 0, async function (done) { 656 file.writeText({ 657 uri: 'internal://app/notdir/File_writeText_013', 658 text: 'sawyerwang', 659 success: function () { 660 console.info('File_writeText_013 mkdir success'); 661 expect(null).assertFail(); 662 }, 663 fail: function (data, code) { 664 expect(code == 300).assertTrue(); 665 console.info('File_writeText_013 , code: ' + code + ', data: ' + data); 666 done(); 667 }, 668 complete: function () { 669 console.info('writeText completed'); 670 } 671 }); 672 }); 673 674 /** 675 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0100 676 * @tc.name File_writeArrayBuffer_001 677 * @tc.desc Write the buffer content to file.(cache path, append mode) The file path is not exist. 678 */ 679 it('File_writeArrayBuffer_001', 0, async function (done) { 680 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 681 file.writeArrayBuffer({ 682 uri: 'internal://cache/File_writeArrayBuffer_001', 683 buffer: buf, 684 append: true, 685 success: function () { 686 console.info('File_writeArrayBuffer_001 call writeArrayBuffer success.'); 687 file.readArrayBuffer({ 688 uri: 'internal://cache/File_writeArrayBuffer_001', 689 success: function (data) { 690 console.info('File_writeArrayBuffer_001 call readArrayBuffer success.' ); 691 file.delete({ 692 uri: 'internal://cache/File_writeArrayBuffer_001', 693 success: function () { 694 console.info('File_writeArrayBuffer_001 delete success'); 695 done(); 696 }, 697 fail: function (data, code) { 698 console.info('File_writeArrayBuffer_001 delete fail, code: ' + code + ', data: ' + data); 699 expect(null).assertFail(); 700 }, 701 }); 702 }, 703 fail: function (data, code) { 704 console.info('File_writeArrayBuffer_001 readArrayBuffer fail, code: ' + code + ', data: ' + data); 705 expect(null).assertFail(); 706 }, 707 }); 708 }, 709 fail: function (data, code) { 710 console.info('File_writeArrayBuffer_001 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 711 expect(null).assertFail(); 712 }, 713 }); 714 }); 715 716 /** 717 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0200 718 * @tc.name File_writeArrayBuffer_002 719 * @tc.desc Write the buffer content to file.(cache path, non-append mode) The file path is not exist. 720 */ 721 it('File_writeArrayBuffer_002', 0, async function (done) { 722 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 723 file.writeArrayBuffer({ 724 uri: 'internal://cache/File_writeArrayBuffer_002', 725 buffer: buf, 726 success: function () { 727 console.info('File_writeArrayBuffer_002 call writeArrayBuffer success.'); 728 file.readArrayBuffer({ 729 uri: 'internal://cache/File_writeArrayBuffer_002', 730 success: function (data) { 731 console.info('File_writeArrayBuffer_002 call readArrayBuffer success.' ); 732 file.delete({ 733 uri: 'internal://cache/File_writeArrayBuffer_002', 734 success: function () { 735 console.info('File_writeArrayBuffer_002 delete success'); 736 done(); 737 }, 738 fail: function (data, code) { 739 console.info('File_writeArrayBuffer_002 delete fail, code: ' + code + ', data: ' + data); 740 expect(null).assertFail(); 741 }, 742 }); 743 }, 744 fail: function (data, code) { 745 console.info('File_writeArrayBuffer_002 readArrayBuffer fail, code: ' + code + ', data: ' + data); 746 expect(null).assertFail(); 747 }, 748 }); 749 }, 750 fail: function (data, code) { 751 console.info('File_writeArrayBuffer_002 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 752 expect(null).assertFail(); 753 }, 754 }); 755 }); 756 757 /** 758 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0300 759 * @tc.name File_writeArrayBuffer_003 760 * @tc.desc Write the buffer content to file.(cache path, append mode) The file path is not exist. 761 */ 762 it('File_writeArrayBuffer_003', 0, async function (done) { 763 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33, 48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 764 file.writeArrayBuffer({ 765 uri: 'internal://cache/File_writeArrayBuffer_003', 766 buffer: buf, 767 success: function () { 768 console.info('File_writeArrayBuffer_003 call writeText success.'); 769 file.writeArrayBuffer({ 770 uri: 'internal://cache/File_writeArrayBuffer_003', 771 buffer: buf, 772 append: true, 773 success: function () { 774 console.info('File_writeArrayBuffer_003 call writeArrayBuffer success.'); 775 file.readArrayBuffer({ 776 uri: 'internal://cache/File_writeArrayBuffer_003', 777 success: function (data) { 778 console.info('File_writeArrayBuffer_003 readArrayBuffer success:' ); 779 done(); 780 }, 781 fail: function (data, code) { 782 console.info('File_writeArrayBuffer_003 readArrayBuffer fail, code: ' + code + ', data: ' + data); 783 expect(null).assertFail(); 784 }, 785 }); 786 }, 787 fail: function (data, code) { 788 console.info('File_writeArrayBuffer_003 writeArrayBuffer append fail, code: ' + code + ', data: ' + data); 789 expect(null).assertFail(); 790 }, 791 }); 792 }, 793 fail: function (data, code) { 794 console.info('File_writeArrayBuffer_003 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 795 expect(null).assertFail(); 796 }, 797 }); 798 }); 799 800 /** 801 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0400 802 * @tc.name File_writeArrayBuffer_004 803 * @tc.desc Write the buffer content to file.(cache path, non-append mode) The file path is exist. 804 */ 805 it('File_writeArrayBuffer_004', 0, async function (done) { 806 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 807 file.writeArrayBuffer({ 808 uri: 'internal://cache/File_writeArrayBuffer_004', 809 buffer: buf, 810 append: false, 811 success: function () { 812 console.info('File_writeArrayBuffer_004 success call writeText success.'); 813 file.writeArrayBuffer({ 814 uri: 'internal://cache/File_writeArrayBuffer_004', 815 buffer: buf, 816 append: false, 817 success: function () { 818 console.info('File_writeArrayBuffer_004 call writeArrayBuffer success.'); 819 file.readArrayBuffer({ 820 uri: 'internal://cache/File_writeArrayBuffer_004', 821 success: function (data) { 822 console.info('File_writeArrayBuffer_004: readArrayBuffer success ' ); 823 file.delete({ 824 uri: 'internal://cache/File_writeArrayBuffer_004', 825 success: function () { 826 console.info('File_writeArrayBuffer_004 call delete success'); 827 done(); 828 }, 829 fail: function (data, code) { 830 console.info('File_writeArrayBuffer_004 delete fail, code: ' + code + ', data: ' + data); 831 expect(null).assertFail(); 832 }, 833 }); 834 }, 835 fail: function (data, code) { 836 console.info('File_writeArrayBuffer_004 readArrayBuffer fail, code: ' + code + ', data: ' + data); 837 expect(null).assertFail(); 838 }, 839 }); 840 }, 841 fail: function (data, code) { 842 console.info('File_writeArrayBuffer_004 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 843 expect(null).assertFail(); 844 }, 845 }); 846 }, 847 fail: function (data, code) { 848 console.info('File_writeArrayBuffer_004 writeText fail, code: ' + code + ', data: ' + data); 849 expect(null).assertFail(); 850 }, 851 }); 852 }); 853 854 /** 855 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0500 856 * @tc.name File_writeArrayBuffer_005 857 * @tc.desc Function of API, set value for position.The file path is exist. 858 */ 859 it('File_writeArrayBuffer_005', 0, async function (done) { 860 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33, 44, 55, 66, 77]); 861 file.writeArrayBuffer({ 862 uri: 'internal://cache/File_writeArrayBuffer_005', 863 buffer: buf, 864 success: function () { 865 console.info('File_writeArrayBuffer_005 call writeText success.'); 866 file.writeArrayBuffer({ 867 uri: 'internal://cache/File_writeArrayBuffer_005', 868 buffer: buf, 869 position: 10, 870 success: function () { 871 console.info('File_writeArrayBuffer_005 call writeArrayBuffer success.'); 872 file.readArrayBuffer({ 873 uri: 'internal://cache/File_writeArrayBuffer_005', 874 success: function (data) { 875 console.info('File_writeArrayBuffer_005 read success:' ); 876 file.delete({ 877 uri: 'internal://cache/File_writeArrayBuffer_005', 878 success: function () { 879 console.info('File_writeArrayBuffer_005 call delete success'); 880 done(); 881 }, 882 fail: function (data, code) { 883 console.info('File_writeArrayBuffer_005 delete fail, code: ' + code + ', data: ' + data); 884 expect(null).assertFail(); 885 }, 886 }); 887 }, 888 fail: function (data, code) { 889 console.info('File_writeArrayBuffer_005 read fail, code: ' + code + ', data: ' + data); 890 expect(null).assertFail(); 891 }, 892 }); 893 }, 894 fail: function (data, code) { 895 console.info('File_writeArrayBuffer_005 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 896 expect(null).assertFail(); 897 }, 898 }); 899 }, 900 fail: function (data, code) { 901 console.info('File_writeArrayBuffer_005 writeText fail, code: ' + code + ', data: ' + data); 902 expect(null).assertFail(); 903 }, 904 }); 905 }); 906 907 /** 908 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0600 909 * @tc.name File_writeArrayBuffer_006 910 * @tc.desc Function of API, not set value for position & append.The file path is exist. 911 */ 912 it('File_writeArrayBuffer_006', 0, async function (done) { 913 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 914 file.writeArrayBuffer({ 915 uri: 'internal://cache/File_writeArrayBuffer_006', 916 buffer: buf, 917 success: function () { 918 console.info('File_writeArrayBuffer_006 call writeText success.'); 919 file.writeArrayBuffer({ 920 uri: 'internal://cache/File_writeArrayBuffer_006', 921 buffer: buf, 922 success: function () { 923 console.info('File_writeArrayBuffer_006 call writeArrayBuffer success.'); 924 file.readArrayBuffer({ 925 uri: 'internal://cache/File_writeArrayBuffer_006', 926 success: function () { 927 console.info('File_writeArrayBuffer_006 call readArrayBuffer pass'); 928 done(); 929 }, 930 fail: function (data, code) { 931 console.info('File_writeArrayBuffer_006 readArrayBuffer fail, code: ' + code + ', data: ' + data); 932 expect(null).assertFail(); 933 }, 934 }); 935 }, 936 fail: function (data, code) { 937 console.info('File_writeArrayBuffer_006 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 938 expect(null).assertFail(); 939 }, 940 }); 941 }, 942 fail: function (data, code) { 943 console.info('File_writeArrayBuffer_006 writeText fail, code: ' + code + ', data: ' + data); 944 expect(null).assertFail(); 945 }, 946 }); 947 }); 948 949 /** 950 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0700 951 * @tc.name File_writeArrayBuffer_007 952 * @tc.desc Function of API, error code: 202 953 */ 954 it('File_writeArrayBuffer_007', 0, async function (done) { 955 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 956 file.writeArrayBuffer({ 957 uri: '', 958 buffer: buf, 959 success: function () { 960 console.info('File_writeArrayBuffer_007 call writeArrayBuffer success.'); 961 expect(null).assertFail(); 962 }, 963 fail: function (data, code) { 964 console.info('File_writeArrayBuffer_007 , code: ' + code + ', data: ' + data); 965 expect(code == 202).assertTrue(); 966 done(); 967 }, 968 }); 969 }); 970 971 /** 972 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0800 973 * @tc.name File_writeArrayBuffer_008 974 * @tc.desc Function of API, error code: 300 975 */ 976 it('File_writeArrayBuffer_008', 0, async function (done) { 977 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 978 file.mkdir({ 979 uri: 'internal://app/File_writeArrayBuffer_008', 980 success: function () { 981 console.info('call mkdir success.'); 982 done(); 983 }, 984 fail: function (data, code) { 985 console.error('call fail callback fail, code: ' + code + ', data: ' + data); 986 }, 987 }); 988 file.writeArrayBuffer({ 989 uri: 'internal://app/notdir/File_writeArrayBuffer_008', 990 buffer: buf, 991 success: function () { 992 console.info('File_writeArrayBuffer_008 call writeArrayBuffer success.'); 993 expect(null).assertFail(); 994 }, 995 fail: function (data, code) { 996 console.info('File_writeArrayBuffer_008 , code: ' + code + ', data: ' + data); 997 expect(code == 300).assertTrue(); 998 done(); 999 }, 1000 }); 1001 }); 1002 1003 /** 1004 * @tc.number SUB_STORAGE_File_writeArrayBuffer_0900 1005 * @tc.name File_writeArrayBuffer_009 1006 * @tc.desc Function of API, error code: 300 1007 */ 1008 it('File_writeArrayBuffer_009', 0, async function (done) { 1009 let buf = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); 1010 file.writeArrayBuffer({ 1011 uri: 'internal://cache/File_writeArrayBuffer_009', 1012 buffer: buf, 1013 success: function () { 1014 console.info('File_writeArrayBuffer_009 call writeArrayBuffer success'); 1015 file.readArrayBuffer({ 1016 uri: 'internal://cache/File_writeArrayBuffer_009', 1017 success: function (data) { 1018 console.info('File_writeArrayBuffer_009 call readArrayBuffer pass'); 1019 file.delete({ 1020 uri: 'internal://cache/File_writeArrayBuffer_009', 1021 success: function () { 1022 console.info('File_writeArrayBuffer_009 call delete success'); 1023 done(); 1024 }, 1025 fail: function (data, code) { 1026 console.info('File_writeArrayBuffer_009 delete fail, code: ' + code + ', data: ' + data); 1027 expect(null).assertFail(); 1028 }, 1029 }); 1030 }, 1031 fail: function (data, code) { 1032 console.info('File_writeArrayBuffer_009 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1033 expect(null).assertFail(); 1034 }, 1035 }); 1036 }, 1037 fail: function (data, code) { 1038 console.info('File_writeArrayBuffer_009 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1039 expect(null).assertFail(); 1040 }, 1041 }); 1042 }); 1043 1044 /** 1045 * @tc.number SUB_STORAGE_File_writeArrayBuffer_1000 1046 * @tc.name File_writeArrayBuffer_010 1047 * @tc.desc Function of API, path = cache, virtual path The test file is exist. 1048 */ 1049 it('File_writeArrayBuffer_010', 0, async function (done) { 1050 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 1051 file.writeArrayBuffer({ 1052 uri: 'internal://cache/../cache/File_writeArrayBuffer_010', 1053 buffer: buf, 1054 append: true, 1055 success: function () { 1056 console.info('File_writeArrayBuffer_010 call writeArrayBuffer success.'); 1057 file.readArrayBuffer({ 1058 uri: 'internal://cache/../cache/File_writeArrayBuffer_010', 1059 success: function (data) { 1060 console.info('File_writeArrayBuffer_010 call readArrayBuffer pass'); 1061 done(); 1062 }, 1063 fail: function (data, code) { 1064 console.info('File_writeArrayBuffer_010 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1065 expect(null).assertFail(); 1066 }, 1067 }); 1068 }, 1069 fail: function (data, code) { 1070 console.info('File_writeArrayBuffer_010 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1071 expect(null).assertFail(); 1072 }, 1073 }); 1074 }); 1075 1076 /** 1077 * @tc.number SUB_STORAGE_File_writeArrayBuffer_1200 1078 * @tc.name File_writeArrayBuffer_012 1079 * @tc.desc Function of API, out of package, Virtual path, save the dir authority.The test file is exist. 1080 */ 1081 it('File_writeArrayBuffer_012', 0, async function (done) { 1082 let buf = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 1083 file.writeArrayBuffer({ 1084 uri: 'internal://app/notdir/File_writeArrayBuffer_012', 1085 buffer: buf, 1086 append: true, 1087 success: function () { 1088 console.info('File_writeArrayBuffer_012 => pass'); 1089 expect(null).assertFail(); 1090 }, 1091 fail: function (data, code) { 1092 console.info('File_writeArrayBuffer_012 , code: ' + code + ', data: ' + data); 1093 expect(code == 300).assertTrue(); 1094 done(); 1095 }, 1096 complete: function () { 1097 console.info('writeArrayBuffer completed'); 1098 } 1099 }); 1100 }); 1101 1102 /** 1103 * @tc.number SUB_STORAGE_File_readText_0100 1104 * @tc.name File_readText_001 1105 * @tc.desc Function of API, readText, app path. 1106 */ 1107 it('File_readText_001', 0, async function (done) { 1108 file.writeText({ 1109 uri: 'internal://cache/File_readText_001', 1110 text: 'Text that just for test.', 1111 success: function () { 1112 console.info('File_readText_001 call writeText success.'); 1113 file.readText({ 1114 uri: 'internal://cache/File_readText_001', 1115 success: function (data) { 1116 console.info('File_readText_001 call readText success.'); 1117 done(); 1118 }, 1119 fail: function (data, code) { 1120 console.info('File_readText_001 readText fail, code: ' + code + ', data: ' + data); 1121 expect(null).assertFail(); 1122 }, 1123 }); 1124 }, 1125 fail: function (data, code) { 1126 console.info('File_readText_001 writeText fail, code: ' + code + ', data: ' + data); 1127 expect(null).assertFail(); 1128 }, 1129 }); 1130 }); 1131 1132 /** 1133 * @tc.number SUB_STORAGE_File_readText_0200 1134 * @tc.name File_readText_002 1135 * @tc.desc Function of API, encoding = UTF-8.The test file is exist. 1136 */ 1137 it('File_readText_002', 0, async function (done) { 1138 file.writeText({ 1139 uri: 'internal://cache/File_readText_002', 1140 text: 'Text that just for test.', 1141 encoding: 'utf-8', 1142 success: function () { 1143 console.info('File_readText_002 call writeText success.'); 1144 file.readText({ 1145 uri: 'internal://cache/File_readText_002', 1146 encoding: 'utf-8', 1147 success: function (data) { 1148 console.info('File_readText_002 call readText success.'); 1149 done(); 1150 }, 1151 fail: function (data, code) { 1152 console.info('File_readText_002 readText fail, code: ' + code + ', data: ' + data); 1153 expect(null).assertFail(); 1154 }, 1155 }); 1156 }, 1157 fail: function (data, code) { 1158 console.info('File_readText_002 writeText fail, code: ' + code + ', data: ' + data); 1159 expect(null).assertFail(); 1160 }, 1161 }); 1162 }); 1163 1164 /** 1165 * @tc.number SUB_STORAGE_File_readText_0300 1166 * @tc.name File_readText_003 1167 * @tc.desc Function of API, error code: 202.The test file and dir is exist. 1168 */ 1169 it('File_readText_003', 0, async function (done) { 1170 file.readText({ 1171 uri: '', 1172 success: function (data) { 1173 console.info(data.text); 1174 expect(null).assertFail(); 1175 }, 1176 fail: function (data, code) { 1177 console.info('File_readText_003 , code: ' + code + ', data: ' + data); 1178 expect(code == 202).assertTrue(); 1179 done(); 1180 }, 1181 }); 1182 }); 1183 1184 /** 1185 * @tc.number SUB_STORAGE_File_readText_0400 1186 * @tc.name File_readText_004 1187 * @tc.desc Function of API, error code: 300.The test dir is exist. 1188 */ 1189 it('File_readText_004', 0, async function (done) { 1190 file.readText({ 1191 uri: 'internal://cache/', 1192 success: function (data) { 1193 console.info(data.text); 1194 expect(null).assertFail(); 1195 }, 1196 fail: function (data, code) { 1197 console.info('File_readText_004 , code: ' + code + ', data: ' + data); 1198 expect(code == 300).assertTrue(); 1199 done(); 1200 }, 1201 }); 1202 }); 1203 1204 /** 1205 * @tc.number SUB_STORAGE_File_readText_0500 1206 * @tc.name File_readText_005 1207 * @tc.desc Function of API, error code: 301.The test file and dir is exist. 1208 */ 1209 it('File_readText_005', 0, async function (done) { 1210 file.readText({ 1211 uri: 'internal://cache/workspace/text.txt', 1212 success: function (data) { 1213 console.info(data.text); 1214 expect(null).assertFail(); 1215 }, 1216 fail: function (data, code) { 1217 console.info('File_readText_005 , code: ' + code + ', data: ' + data); 1218 expect(code == 301).assertTrue(); 1219 done(); 1220 }, 1221 }); 1222 }); 1223 1224 /** 1225 * @tc.number SUB_STORAGE_File_readText_0600 1226 * @tc.name File_readText_006 1227 * @tc.desc Function of API, readText, cache path. 1228 */ 1229 it('File_readText_006', 0, async function (done) { 1230 file.writeText({ 1231 uri: 'internal://cache/File_readText_006', 1232 text: 'test', 1233 success: function () { 1234 console.info('File_readText_006 call success'); 1235 file.readText({ 1236 uri: 'internal://cache/File_readText_006', 1237 success: function (data) { 1238 console.info('File_readText_006 call success' ); 1239 file.delete({ 1240 uri: 'internal://cache/File_readText_006', 1241 success: function () { 1242 console.info('File_readText_006 call success'); 1243 done(); 1244 }, 1245 fail: function (data, code) { 1246 console.info('File_readText_006 delete fail, code: ' + code + ', data: ' + data); 1247 expect(null).assertFail(); 1248 }, 1249 }); 1250 }, 1251 fail: function (data, code) { 1252 console.info('File_readText_006 readText fail, code: ' + code + ', data: ' + data); 1253 expect(null).assertFail(); 1254 }, 1255 }); 1256 }, 1257 fail: function (data, code) { 1258 console.info('File_readText_006 writeText fail, code: ' + code + ', data: ' + data); 1259 expect(null).assertFail(); 1260 }, 1261 }); 1262 }); 1263 1264 /** 1265 * @tc.number SUB_STORAGE_File_readText_0700 1266 * @tc.name File_readText_007 1267 * @tc.desc Function of API, virtual path.The test file is exist. 1268 */ 1269 it('File_readText_007', 0, async function (done) { 1270 file.writeText({ 1271 uri: 'internal://cache/../files/../files/File_readText_007', 1272 text: 'Text that just for test.', 1273 success: function () { 1274 console.info('File_readText_007 call writeText success.'); 1275 file.readText({ 1276 uri: 'internal://cache/../files/../files/File_readText_007', 1277 success: function (data) { 1278 console.info('File_readText_007 call readText success. data.text:' ); 1279 file.delete({ 1280 uri: 'internal://cache/../files/../files/File_readText_007', 1281 success: function () { 1282 console.info('File_readText_007 call delete success'); 1283 done(); 1284 }, 1285 fail: function (data, code) { 1286 console.info('File_readText_007 delete fail, code: ' + code + ', data: ' + data); 1287 expect(null).assertFail(); 1288 }, 1289 }); 1290 }, 1291 fail: function (data, code) { 1292 console.info('File_readText_007 readText fail, code: ' + code + ', data: ' + data); 1293 expect(null).assertFail(); 1294 }, 1295 }); 1296 }, 1297 fail: function (data, code) { 1298 console.info('File_readText_007 writeText fail, code: ' + code + ', data: ' + data); 1299 expect(null).assertFail(); 1300 }, 1301 }); 1302 }); 1303 1304 /** 1305 * @tc.number SUB_STORAGE_File_readText_0800 1306 * @tc.name File_readText_008 1307 * @tc.desc Function of API, virtual path.Test whether the files returned are equal. 1308 */ 1309 it("File_readText_008", 0, async function (done) { 1310 let fpath = await nextFileName("File_readText_008"); 1311 let text = "0123456789abcdefg"; 1312 expect(prepareFile(fpath, text)).assertTrue(); 1313 sleep(10); 1314 try { 1315 file.readText({ 1316 uri: "internal://cache/File_readText_008", 1317 success: function (data) { 1318 console.info("call readText success: " + data.text); 1319 expect(text == data.text).assertTrue(); 1320 fileio.unlinkSync(fpath); 1321 done(); 1322 }, 1323 fail: function (data, code) { 1324 console.error("call fail callback fail, code: " + code + ", data: " + data); 1325 expect(null).assertFail(); 1326 }, 1327 complete: function () { 1328 console.info('readText completed'); 1329 } 1330 }); 1331 } catch (e) { 1332 console.info("File_readText_008 has failed for " + e); 1333 expect(null).assertFail(); 1334 } 1335 }); 1336 1337 /** 1338 * @tc.number SUB_STORAGE_File_read_array_buffer_0100 1339 * @tc.name File_read_array_buffer_001 1340 * @tc.desc Function of API, readArrayBuffer, cache path.position = 0, length = 10. 1341 */ 1342 it('File_read_array_buffer_001', 0, async function (done) { 1343 var buffer = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 1344 file.writeArrayBuffer({ 1345 uri: 'internal://cache/File_read_array_buffer_001', 1346 buffer: buffer, 1347 success: function () { 1348 console.info('File_read_array_buffer_001 call writeArrayBuffer success.'); 1349 file.readArrayBuffer({ 1350 uri: 'internal://cache/File_read_array_buffer_001', 1351 position: 0, 1352 length: 10, 1353 success: function (data) { 1354 console.info('File_read_array_buffer_001 call readArrayBuffer pass'); 1355 file.delete({ 1356 uri: 'internal://cache/File_read_array_buffer_001', 1357 success: function () { 1358 console.info('File_read_array_buffer_001 call delete success'); 1359 done(); 1360 }, 1361 fail: function (data, code) { 1362 console.info('File_read_array_buffer_001 delete fail, code: ' + code + ', data: ' + data); 1363 expect(null).assertFail(); 1364 }, 1365 }); 1366 }, 1367 fail: function (data, code) { 1368 console.info('File_read_array_buffer_001 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1369 expect(null).assertFail(); 1370 }, 1371 }); 1372 }, 1373 fail: function (data, code) { 1374 console.info('File_read_array_buffer_001 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1375 expect(null).assertFail(); 1376 }, 1377 }); 1378 }); 1379 1380 /** 1381 * @tc.number SUB_STORAGE_File_read_array_buffer_0200 1382 * @tc.name File_read_array_buffer_002 1383 * @tc.desc Function of API, readArrayBuffer, 1384 */ 1385 it('File_read_array_buffer_002', 0, async function (done) { 1386 var buffer = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 1387 file.writeArrayBuffer({ 1388 uri: 'internal://cache/File_read_array_buffer_002', 1389 buffer: buffer, 1390 success: function () { 1391 console.info('File_read_array_buffer_002 call writeArrayBuffer success.'); 1392 file.readArrayBuffer({ 1393 uri: 'internal://cache/File_read_array_buffer_002', 1394 success: function (data) { 1395 console.info('File_read_array_buffer_002 call readArrayBuffer pass'); 1396 done(); 1397 }, 1398 fail: function (data, code) { 1399 console.info('File_read_array_buffer_002 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1400 expect(null).assertFail(); 1401 }, 1402 }); 1403 }, 1404 fail: function (data, code) { 1405 console.info('File_read_array_buffer_002 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1406 expect(null).assertFail(); 1407 }, 1408 }); 1409 }); 1410 1411 /** 1412 * @tc.number SUB_STORAGE_File_read_array_buffer_0300 1413 * @tc.name File_read_array_buffer_003 1414 * @tc.desc Function of API, readArrayBuffer, wrong uri. 1415 */ 1416 it('File_read_array_buffer_003', 0, async function (done) { 1417 file.readArrayBuffer({ 1418 uri: '', 1419 success: function (data) { 1420 console.info('File_read_array_buffer_003 call readArrayBuffer success: ' ); 1421 expect(null).assertFail(); 1422 }, 1423 fail: function (data, code) { 1424 console.info('File_read_array_buffer_003 , code: ' + code + ', data: ' + data); 1425 expect(code == 202).assertTrue(); 1426 done(); 1427 }, 1428 }); 1429 }); 1430 1431 /** 1432 * @tc.number SUB_STORAGE_File_read_array_buffer_0400 1433 * @tc.name File_read_array_buffer_004 1434 * @tc.desc Function of API, readArrayBuffer, wrong position. 1435 */ 1436 it('File_read_array_buffer_004', 0, async function (done) { 1437 let fpath = await fileName('File_read_array_buffer_004'); 1438 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 1439 file.readArrayBuffer({ 1440 uri: fpath, 1441 position: 100, 1442 success: function (data) { 1443 console.info('File_read_array_buffer_004 call readArrayBuffer success: ' ); 1444 expect(null).assertFail(); 1445 }, 1446 fail: function (data, code) { 1447 console.info('File_read_array_buffer_004 , code: ' + code + ', data: ' + data); 1448 expect(code == 202).assertTrue(); 1449 done(); 1450 }, 1451 }); 1452 }); 1453 1454 /** 1455 * @tc.number SUB_STORAGE_File_read_array_buffer_0500 1456 * @tc.name File_read_array_buffer_005 1457 * @tc.desc Function of API, readArrayBuffer, wrong length. 1458 */ 1459 it('File_read_array_buffer_005', 0, async function (done) { 1460 let fpath = await fileName('File_read_array_buffer_005'); 1461 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 1462 file.readArrayBuffer({ 1463 uri: fpath, 1464 length: -1, 1465 success: function (data) { 1466 console.info('File_read_array_buffer_005 call readArrayBuffer success: ' ); 1467 expect(null).assertFail(); 1468 }, 1469 fail: function (data, code) { 1470 console.info('File_read_array_buffer_005 , code: ' + code + ', data: ' + data); 1471 expect(code == 202).assertTrue(); 1472 done(); 1473 }, 1474 }); 1475 }); 1476 1477 /** 1478 * @tc.number SUB_STORAGE_File_read_array_buffer_0600 1479 * @tc.name File_read_array_buffer_006 1480 * @tc.desc Function of API, error code: 202 Set uri is dir path. 1481 */ 1482 it('File_read_array_buffer_006', 0, async function (done) { 1483 file.readArrayBuffer({ 1484 uri: 'internal://app', 1485 success: function (data) { 1486 console.info('File_read_array_buffer_006 call readArrayBuffer success: ' ); 1487 expect(null).assertFail(); 1488 }, 1489 fail: function (data, code) { 1490 console.info('File_read_array_buffer_006 , code: ' + code + ', data: ' + data); 1491 expect(code == 202).assertTrue(); 1492 done(); 1493 }, 1494 }); 1495 }); 1496 1497 /** 1498 * @tc.number SUB_STORAGE_File_read_array_buffer_0700 1499 * @tc.name File_read_array_buffer_007 1500 * @tc.desc Function of API, error code: 301 1501 */ 1502 it('File_read_array_buffer_007', 0, async function (done) { 1503 file.readArrayBuffer({ 1504 uri: 'internal://cache/File_read_array_buffer_007', 1505 success: function (data) { 1506 console.info('File_read_array_buffer_007 call readArrayBuffer success: ' ); 1507 expect(null).assertFail(); 1508 }, 1509 fail: function (data, code) { 1510 console.info('File_read_array_buffer_007 , code: ' + code + ', data: ' + data); 1511 expect(code == 301).assertTrue(); 1512 done(); 1513 }, 1514 }); 1515 }); 1516 1517 /** 1518 * @tc.number SUB_STORAGE_File_read_array_buffer_0800 1519 * @tc.name File_read_array_buffer_008 1520 * @tc.desc Function of API, cache path.The test file is exist. 1521 */ 1522 it('File_read_array_buffer_008', 0, async function (done) { 1523 let buf = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); 1524 file.writeArrayBuffer({ 1525 uri: 'internal://cache/File_read_array_buffer_008', 1526 buffer: buf, 1527 success: function () { 1528 console.info('File_read_array_buffer_008 call writeArrayBuffer success'); 1529 file.readArrayBuffer({ 1530 uri: 'internal://cache/File_read_array_buffer_008', 1531 success: function (data) { 1532 console.info('File_read_array_buffer_008 call readArrayBuffer success ' ); 1533 file.delete({ 1534 uri: 'internal://cache/File_read_array_buffer_008', 1535 success: function () { 1536 console.info('File_read_array_buffer_008 call delete success'); 1537 done(); 1538 }, 1539 fail: function (data, code) { 1540 console.info('File_read_array_buffer_008 delete fail, code: ' + code + ', data: ' + data); 1541 expect(null).assertFail(); 1542 }, 1543 }); 1544 }, 1545 fail: function (data, code) { 1546 console.info('File_read_array_buffer_008 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1547 expect(null).assertFail(); 1548 }, 1549 }); 1550 }, 1551 fail: function (data, code) { 1552 console.info('File_read_array_buffer_008 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1553 expect(null).assertFail(); 1554 }, 1555 }); 1556 }); 1557 1558 /** 1559 * @tc.number SUB_STORAGE_File_read_array_buffer_0900 1560 * @tc.name File_read_array_buffer_009 1561 * @tc.desc Function of API, virtual path.The test file is exist. 1562 */ 1563 it('File_read_array_buffer_009', 0, async function (done) { 1564 var buffer = new Uint8Array([48, 49, 50, 51, 65, 66, 67, 68, 32, 33]); 1565 file.writeArrayBuffer({ 1566 uri: 'internal://cache/../cache/File_read_array_buffer_009', 1567 buffer: buffer, 1568 success: function () { 1569 console.info('File_read_array_buffer_009 call writeArrayBuffer success.'); 1570 file.readArrayBuffer({ 1571 uri: 'internal://cache/../cache/File_read_array_buffer_009', 1572 position: 0, 1573 length: 10, 1574 success: function (data) { 1575 console.info('File_read_array_buffer_009 call readArrayBuffer success. data.buffer:' ); 1576 file.delete({ 1577 uri: 'internal://cache/../cache/File_read_array_buffer_009', 1578 success: function () { 1579 console.info('File_read_array_buffer_009 call delete success'); 1580 done(); 1581 }, 1582 fail: function (data, code) { 1583 console.info('File_read_array_buffer_009 delete fail, code: ' + code + ', data: ' + data); 1584 expect(null).assertFail(); 1585 }, 1586 }); 1587 }, 1588 fail: function (data, code) { 1589 console.info('File_read_array_buffer_009 readArrayBuffer fail, code: ' + code + ', data: ' + data); 1590 expect(null).assertFail(); 1591 }, 1592 complete: function () { 1593 console.info('readArrayBuffer completed'); 1594 } 1595 }); 1596 }, 1597 fail: function (data, code) { 1598 console.info('File_read_array_buffer_009 writeArrayBuffer fail, code: ' + code + ', data: ' + data); 1599 expect(null).assertFail(); 1600 }, 1601 }); 1602 }); 1603 1604 /** 1605 * @tc.number SUB_STORAGE_File_access_0100 1606 * @tc.name File_access_001 1607 * @tc.desc Function of API, access, cache path.The test file is exist. 1608 */ 1609 it('File_access_001', 0, async function (done) { 1610 file.writeText({ 1611 uri: 'internal://cache/File_access_001', 1612 text: 'Text that just for test.', 1613 success: function () { 1614 console.info('File_access_001 call writeText success.'); 1615 file.access({ 1616 uri: 'internal://cache/File_access_001', 1617 success: function () { 1618 console.info('File_access_001 call access success.'); 1619 file.delete({ 1620 uri: 'internal://cache/File_access_001', 1621 success: function () { 1622 console.info('File_access_001 call delete success.'); 1623 done(); 1624 }, 1625 fail: function (data, code) { 1626 console.info('File_access_001 delete fail, code: ' + code + ', data: ' + data); 1627 expect(null).assertFail(); 1628 }, 1629 }); 1630 }, 1631 fail: function (data, code) { 1632 console.info('File_access_001 access fail, code: ' + code + ', data: ' + data); 1633 expect(null).assertFail(); 1634 }, 1635 }); 1636 }, 1637 fail: function (data, code) { 1638 console.info('File_access_001 writeText fail, code: ' + code + ', data: ' + data); 1639 expect(null).assertFail(); 1640 }, 1641 }); 1642 }); 1643 1644 /** 1645 * @tc.number SUB_STORAGE_File_access_0200 1646 * @tc.name File_access_002 1647 * @tc.desc Function of API, access, app path.The test file is exist. 1648 */ 1649 it('File_access_002', 0, async function (done) { 1650 file.mkdir({ 1651 uri: 'internal://cache/File_access_002', 1652 success: function () { 1653 console.info('File_access_002 call mkdir success.'); 1654 file.access({ 1655 uri: 'internal://cache/File_access_002', 1656 success: function () { 1657 console.info('File_access_002 call access success.'); 1658 file.rmdir({ 1659 uri: 'internal://cache/File_access_002', 1660 success: function () { 1661 console.info('File_access_002 call rmdir success.'); 1662 done(); 1663 }, 1664 fail: function (data, code) { 1665 console.info('File_access_002 rmdir fail, code: ' + code + ', data: ' + data); 1666 expect(null).assertFail(); 1667 }, 1668 }); 1669 }, 1670 fail: function (data, code) { 1671 console.info('File_access_002 access fail, code: ' + code + ', data: ' + data); 1672 expect(null).assertFail(); 1673 }, 1674 }); 1675 }, 1676 fail: function (data, code) { 1677 console.info('File_access_002 mkdir fail, code: ' + code + ', data: ' + data); 1678 expect(null).assertFail(); 1679 }, 1680 }); 1681 }); 1682 1683 /** 1684 * @tc.number SUB_STORAGE_File_access_0300 1685 * @tc.name File_access_003 1686 * @tc.desc Function of API, error code: 202 The test file and dir are exist. 1687 */ 1688 it('File_access_003', 0, async function (done) { 1689 let fpath = await fileName('File_access_003'); 1690 file.access({ 1691 uri: fpath, 1692 success: function () { 1693 console.info('File_access_003 call access success.'); 1694 expect(null).assertFail(); 1695 }, 1696 fail: function (data, code) { 1697 console.info('File_access_003 , code: ' + code + ', data: ' + data); 1698 expect(code == 202).assertTrue(); 1699 done(); 1700 }, 1701 }); 1702 }); 1703 1704 /** 1705 * @tc.number SUB_STORAGE_File_access_0400 1706 * @tc.name File_access_004 1707 * @tc.desc Function of API, error code: 301 1708 */ 1709 it('File_access_004', 0, async function (done) { 1710 file.access({ 1711 uri: 'internal://app/File_access_004.txt', 1712 success: function () { 1713 console.info('File_access_004 call access success.'); 1714 expect(null).assertFail(); 1715 }, 1716 fail: function (data, code) { 1717 console.info('File_access_004 , code: ' + code + ', data: ' + data); 1718 expect(code == 301).assertTrue(); 1719 done(); 1720 }, 1721 }); 1722 }); 1723 1724 /** 1725 * @tc.number SUB_STORAGE_File_access_0500 1726 * @tc.name File_access_005 1727 * @tc.desc Function of API, error code: 301 1728 */ 1729 it('File_access_005', 0, async function (done) { 1730 file.access({ 1731 uri: 'internal://app/File_access_005', 1732 success: function () { 1733 console.info('File_access_005 call access success.'); 1734 expect(null).assertFail(); 1735 }, 1736 fail: function (data, code) { 1737 console.info('File_access_005 , code: ' + code + ', data: ' + data); 1738 expect(code == 301).assertTrue(); 1739 done(); 1740 }, 1741 }); 1742 }); 1743 1744 /** 1745 * @tc.number SUB_STORAGE_File_access_0600 1746 * @tc.name File_access_006 1747 * @tc.desc Function of API, parameter more than 4096.The test file and dir are exist. 1748 */ 1749 it('File_access_006', 0, async function (done) { 1750 let firstPath = randomString(32); 1751 let dpath = await fileName(firstPath); 1752 let uri = 'internal://cache/' + firstPath; 1753 fileio.mkdirSync(dpath); 1754 for (let i = 0; i < 16; i++) { 1755 console.info('time' + i); 1756 let sonPath = randomString(251); 1757 uri = uri + '/f' + sonPath; 1758 } 1759 file.access({ 1760 uri: uri, 1761 success: function () { 1762 console.info('File_access_006 => pass'); 1763 expect(null).assertFail(); 1764 }, 1765 fail: function (data, code) { 1766 console.info('File_access_006 , code: ' + code + ', data: ' + data); 1767 expect(code == 300).assertTrue(); 1768 fileio.rmdirSync(dpath); 1769 done(); 1770 }, 1771 }); 1772 1773 }); 1774 1775 /** 1776 * @tc.number SUB_STORAGE_File_access_0700 1777 * @tc.name File_access_007 1778 * @tc.desc Function of API, app path.The test file is exist. 1779 */ 1780 it('File_access_007', 0, async function (done) { 1781 file.writeText({ 1782 uri: 'internal://cache/File_access_007', 1783 text: 'hello', 1784 success: function () { 1785 console.info('File_access_007 writeText success '); 1786 file.access({ 1787 uri: 'internal://cache/File_access_007', 1788 success: function () { 1789 console.info('File_access_007 access success'); 1790 file.delete({ 1791 uri: 'internal://cache/File_access_007', 1792 success: function () { 1793 console.info('File_access_007 delete success'); 1794 done(); 1795 }, 1796 fail: function (data, code) { 1797 console.info('File_access_007 delete fail, code: ' + code + ', data: ' + data); 1798 expect(null).assertFail(); 1799 }, 1800 }); 1801 }, 1802 fail: function (data, code) { 1803 console.info('File_access_007 access fail, code: ' + code + ', data: ' + data); 1804 expect(null).assertFail(); 1805 }, 1806 }); 1807 }, 1808 fail: function (data, code) { 1809 console.info('File_access_007 writeText fail, code: ' + code + ', data: ' + data); 1810 expect(null).assertFail(); 1811 }, 1812 }); 1813 }); 1814 1815 /** 1816 * @tc.number SUB_STORAGE_File_access_0800 1817 * @tc.name File_access_008 1818 * @tc.desc Function of API, virtual path.The test file is exist. 1819 */ 1820 it('File_access_008', 0, async function (done) { 1821 file.writeText({ 1822 uri: 'internal://cache/../cache/File_access_008', 1823 text: 'Text that just for test.', 1824 success: function () { 1825 console.info('File_access_008 writeText success.'); 1826 file.access({ 1827 uri: 'internal://cache/../cache/File_access_008', 1828 success: function () { 1829 console.info('File_access_008 call access success.'); 1830 file.delete({ 1831 uri: 'internal://cache/../cache/File_access_008', 1832 success: function () { 1833 console.info('File_access_008 call delete success.'); 1834 done(); 1835 }, 1836 fail: function (data, code) { 1837 console.info('File_access_008 delete fail, code: ' + code + ', data: ' + data); 1838 expect(null).assertFail(); 1839 } 1840 }); 1841 }, 1842 fail: function (data, code) { 1843 console.info('File_access_008 access fail, code: ' + code + ', data: ' + data); 1844 expect(null).assertFail(); 1845 }, 1846 complete: function () { 1847 console.info('access completed'); 1848 } 1849 }); 1850 }, 1851 fail: function (data, code) { 1852 console.info('File_access_008 writeText fail, code: ' + code + ', data: ' + data); 1853 expect(null).assertFail(); 1854 }, 1855 }); 1856 }); 1857 1858 /** 1859 * @tc.number SUB_STORAGE_File_mkdir_0100 1860 * @tc.name File_mkdir_001 1861 * @tc.desc Function of API, mkdir, app path. 1862 */ 1863 it('File_mkdir_001', 0, async function (done) { 1864 file.mkdir({ 1865 uri: 'internal://cache/File_mkdir_001', 1866 success: function () { 1867 console.info('File_mkdir_001 call mkdir success.'); 1868 file.rmdir({ 1869 uri: 'internal://cache/File_mkdir_001', 1870 success: function () { 1871 console.info('File_mkdir_001 call rmdir success.'); 1872 done(); 1873 }, 1874 fail: function (data, code) { 1875 console.info('File_mkdir_001 rmdir fail, code: ' + code + ', data: ' + data); 1876 expect(null).assertFail(); 1877 }, 1878 }); 1879 }, 1880 fail: function (data, code) { 1881 console.info('File_mkdir_001 mkdir fail, code: ' + code + ', data: ' + data); 1882 expect(null).assertFail(); 1883 }, 1884 }); 1885 }); 1886 1887 /** 1888 * @tc.number SUB_STORAGE_File_mkdir_0200 1889 * @tc.name File_mkdir_002 1890 * @tc.desc Function of API, mkdir, recursive not set value. 1891 */ 1892 it('File_mkdir_002', 0, async function (done) { 1893 file.mkdir({ 1894 uri: 'internal://app/test/File_mkdir_002', 1895 success: function () { 1896 console.info('File_mkdir_002 call mkdir success.'); 1897 expect(null).assertFail(); 1898 }, 1899 fail: function (data, code) { 1900 console.info('File_mkdir_002 , code: ' + code + ', data: ' + data); 1901 expect(code == 300).assertTrue(); 1902 done(); 1903 }, 1904 }); 1905 }); 1906 1907 /** 1908 * @tc.number SUB_STORAGE_File_mkdir_0300 1909 * @tc.name File_mkdir_003 1910 * @tc.desc Function of API, mkdir, recursive. 1911 */ 1912 it('File_mkdir_003', 0, async function (done) { 1913 file.mkdir({ 1914 uri: 'internal://cache/test/File_mkdir_003d', 1915 recursive: true, 1916 success: function () { 1917 console.info('File_mkdir_003 call mkdir success.'); 1918 done(); 1919 }, 1920 fail: function (data, code) { 1921 console.info('File_mkdir_003 , code: ' + code + ', data: ' + data); 1922 expect(null).assertFail(); 1923 }, 1924 }); 1925 }); 1926 1927 /** 1928 * @tc.number SUB_STORAGE_File_mkdir_0400 1929 * @tc.name File_mkdir_004 1930 * @tc.desc Function of API, error code: 202 1931 */ 1932 it('File_mkdir_004', 0, async function (done) { 1933 file.mkdir({ 1934 uri: 'internal://files/test/File_mkdir_002d', 1935 success: function () { 1936 console.info('File_mkdir_004 call mkdir success.'); 1937 expect(null).assertFail(); 1938 }, 1939 fail: function (data, code) { 1940 console.info('File_mkdir_004, code: ' + code + ', data: ' + data); 1941 expect(code == 202).assertTrue(); 1942 done(); 1943 }, 1944 }); 1945 }); 1946 1947 /** 1948 * @tc.number SUB_STORAGE_File_mkdir_0500 1949 * @tc.name File_mkdir_005 1950 * @tc.desc Function of API, special characters. 1951 */ 1952 it('File_mkdir_005', 0, async function (done) { 1953 file.mkdir({ 1954 uri: 'internal://cache/！@/<>', 1955 success: function () { 1956 console.info('File_mkdir_005 mkdir success'); 1957 expect(null).assertFail(); 1958 }, 1959 fail: function (data, code) { 1960 console.info('File_mkdir_005 fail, code: ' + code + ', data: ' + data); 1961 expect(code == 300).assertTrue(); 1962 done(); 1963 }, 1964 }); 1965 }); 1966 1967 /** 1968 * @tc.number SUB_STORAGE_File_mkdir_0600 1969 * @tc.name File_mkdir_006 1970 * @tc.desc Function of API, parameter too long. 1971 */ 1972 it('File_mkdir_006', 0, async function (done) { 1973 let fileName = randomString(257); 1974 file.mkdir({ 1975 uri: 'internal://cache/' + fileName, 1976 success: function () { 1977 console.info('File_mkdir_006 mkdir success'); 1978 expect(null).assertFail(); 1979 }, 1980 fail: function (data, code) { 1981 console.info('File_mkdir_006 =>fail ,code：' + code + ',data: ' + data); 1982 expect(code == 300).assertTrue(); 1983 done(); 1984 }, 1985 }); 1986 }); 1987 1988 /** 1989 * @tc.number SUB_STORAGE_File_mkdir_0700 1990 * @tc.name File_mkdir_007 1991 * @tc.desc Function of API, cache path. 1992 */ 1993 it('File_mkdir_007', 0, async function (done) { 1994 file.mkdir({ 1995 uri: 'internal://cache/File_mkdir_007d', 1996 success: function () { 1997 console.info('File_mkdir_007 mkdir success'); 1998 file.rmdir({ 1999 uri: 'internal://cache/File_mkdir_007d', 2000 success: function () { 2001 console.info('File_mkdir_007 delete success'); 2002 done(); 2003 }, 2004 fail: function (data, code) { 2005 console.info('File_mkdir_007 delete fail, code: ' + code + ', data: ' + data); 2006 expect(null).assertFail(); 2007 }, 2008 }); 2009 }, 2010 fail: function (data, code) { 2011 console.info('File_mkdir_007 mkdir fail, code: ' + code + ', data: ' + data); 2012 expect(null).assertFail(); 2013 }, 2014 }); 2015 }); 2016 2017 /** 2018 * @tc.number SUB_STORAGE_File_mkdir_0800 2019 * @tc.name File_mkdir_008 2020 * @tc.desc Function of API, virtual path. 2021 */ 2022 it('File_mkdir_008', 0, async function (done) { 2023 file.mkdir({ 2024 uri: 'internal://cache/../files/File_mkdir_008', 2025 success: function () { 2026 console.info('File_mkdir_008 call mkdir success.'); 2027 file.rmdir({ 2028 uri: 'internal://cache/../files/File_mkdir_008', 2029 success: function () { 2030 console.info('File_mkdir_008 call rmdir success.'); 2031 done(); 2032 }, 2033 fail: function (data, code) { 2034 console.info('File_mkdir_008 rmdir fail, code: ' + code + ', data: ' + data); 2035 expect(null).assertFail(); 2036 }, 2037 }); 2038 }, 2039 fail: function (data, code) { 2040 console.info('File_mkdir_008 mkdir fail, code: ' + code + ', data: ' + data); 2041 expect(null).assertFail(); 2042 }, 2043 }); 2044 }); 2045 2046 /** 2047 * @tc.number SUB_STORAGE_File_mkdir_1000 2048 * @tc.name File_mkdir_010 2049 * @tc.desc Function of API, out of package, out of package, Virtual path, save the dir authority. 2050 */ 2051 it('File_mkdir_010', 0, async function (done) { 2052 file.mkdir({ 2053 uri: 'internal://app/notdir/File_mkdir_010', 2054 success: function () { 2055 console.info('File_mkdir_010 call mkdir success.'); 2056 expect(null).assertFail(); 2057 }, 2058 fail: function (data, code) { 2059 console.info('File_mkdir_010 call mkdir callback fail, code: ' + code + ', data: ' + data); 2060 expect(code == 300).assertTrue(); 2061 done(); 2062 }, 2063 complete: function () { 2064 console.info('mkdir completed'); 2065 } 2066 }); 2067 }); 2068 2069 /** 2070 * @tc.number SUB_STORAGE_File_rmdir_0100 2071 * @tc.name File_rmdir_001 2072 * @tc.desc Function of API, rmdir, app path.The test dir is exist, and it can be delete, the dir is empty. 2073 */ 2074 it('File_rmdir_001', 0, async function (done) { 2075 file.mkdir({ 2076 uri: 'internal://cache/File_rmdir_001', 2077 success: function () { 2078 console.info('File_rmdir_001 call mkdir success.'); 2079 file.rmdir({ 2080 uri: 'internal://cache/File_rmdir_001', 2081 success: function () { 2082 console.info('File_rmdir_001 call rmdir success.'); 2083 done(); 2084 }, 2085 fail: function (data, code) { 2086 console.info('File_rmdir_001 rmdir fail, code: ' + code + ', data: ' + data); 2087 expect(null).assertFail(); 2088 }, 2089 }); 2090 }, 2091 fail: function (data, code) { 2092 console.info('File_rmdir_001 mkdir fail, code: ' + code + ', data: ' + data); 2093 expect(null).assertFail(); 2094 }, 2095 }); 2096 }); 2097 2098 /** 2099 * @tc.number SUB_STORAGE_File_rmdir_0200 2100 * @tc.name File_rmdir_002 2101 * @tc.desc Function of API, recursive not set value.The test dir is exist, and it not empty. 2102 */ 2103 it('File_rmdir_002', 0, async function (done) { 2104 file.mkdir({ 2105 uri: 'internal://app/test/File_rmdir_002', 2106 recursive: true, 2107 success: function () { 2108 console.info('File_rmdir_002 mkdir success.'); 2109 file.rmdir({ 2110 uri: 'internal://app/test', 2111 recursive: false, 2112 success: function () { 2113 console.info('File_rmdir_002 call rmdir success.'); 2114 expect(null).assertFail(); 2115 }, 2116 fail: function (data, code) { 2117 console.info('File_rmdir_002 fail, code: ' + code + ', data: ' + data); 2118 expect(code == 301 || code == 300).assertTrue(); 2119 done(); 2120 }, 2121 }); 2122 }, 2123 fail: function (data, code) { 2124 console.info('File_rmdir_002 fail, code: ' + code + ', data: ' + data); 2125 expect(null).assertFail(); 2126 }, 2127 }); 2128 }); 2129 2130 /** 2131 * @tc.number SUB_STORAGE_File_rmdir_0300 2132 * @tc.name File_rmdir_003 2133 * @tc.desc Function of API, recursive = ture.The test dir is exist, and it not empty. 2134 */ 2135 it('File_rmdir_003', 0, async function (done) { 2136 file.mkdir({ 2137 uri: 'internal://cache/test/File_rmdir_003/File_rmdir_003_1/File_rmdir_003_2', 2138 recursive: true, 2139 success: function () { 2140 console.info('File_rmdir_003 mkdir success.'); 2141 file.mkdir({ 2142 uri: 'internal://cache/test/File_rmdir_003_1/File_rmdir_003_1/File_rmdir_003_2', 2143 recursive: true, 2144 success: function () { 2145 console.info('File_rmdir_003 mkdir success.'); 2146 file.mkdir({ 2147 uri: 'internal://cache/test/File_rmdir_003_2/File_rmdir_003_1/File_rmdir_003_2', 2148 recursive: true, 2149 success: function () { 2150 console.info('File_rmdir_003 mkdir success.'); 2151 file.rmdir({ 2152 uri: 'internal://cache/test', 2153 recursive: true, 2154 success: function () { 2155 console.info('File_rmdir_003 call rmdir success.'); 2156 done(); 2157 }, 2158 fail: function (data, code) { 2159 console.info('File_rmdir_003 , code: ' + code + ', data: ' + data); 2160 expect(null).assertFail(); 2161 }, 2162 }); 2163 }, 2164 fail: function (data, code) { 2165 console.info('File_rmdir_003 fail, code: ' + code + ', data: ' + data); 2166 expect(null).assertFail(); 2167 }, 2168 }); 2169 }, 2170 fail: function (data, code) { 2171 console.info('File_rmdir_003 fail, code: ' + code + ', data: ' + data); 2172 expect(null).assertFail(); 2173 }, 2174 }); 2175 }, 2176 fail: function (data, code) { 2177 console.info('File_rmdir_003 fail, code: ' + code + ', data: ' + data); 2178 expect(null).assertFail(); 2179 }, 2180 }); 2181 }); 2182 2183 /** 2184 * @tc.number SUB_STORAGE_File_rmdir_0400 2185 * @tc.name File_rmdir_004 2186 * @tc.desc Function of API, error code: 202 2187 */ 2188 it('File_rmdir_004', 0, async function (done) { 2189 file.rmdir({ 2190 uri: '/data/accounts/account_0/appdata/ohos.acts.distributeddatamgr.distributedfile/cache/', 2191 success: function () { 2192 console.info('File_rmdir_004 call rmdir success.'); 2193 expect(null).assertFail(); 2194 }, 2195 fail: function (data, code) { 2196 console.info('File_rmdir_004 , code: ' + code + ', data: ' + data); 2197 expect(code == 202).assertTrue(); 2198 done(); 2199 }, 2200 }); 2201 }); 2202 2203 /** 2204 * @tc.number SUB_STORAGE_File_rmdir_0500 2205 * @tc.name File_rmdir_005 2206 * @tc.desc Function of API, error code: 301 2207 */ 2208 it('File_rmdir_005', 0, async function (done) { 2209 file.rmdir({ 2210 uri: 'internal://app/123', 2211 success: function () { 2212 console.info('File_rmdir_005 call rmdir success.'); 2213 expect(null).assertFail(); 2214 }, 2215 fail: function (data, code) { 2216 console.info('File_rmdir_005 rmdir fail, code: ' + code + ', data: ' + data); 2217 expect(code == 301).assertTrue(); 2218 done(); 2219 }, 2220 }); 2221 }); 2222 2223 /** 2224 * @tc.number SUB_STORAGE_File_rmdir_0600 2225 * @tc.name File_rmdir_006 2226 * @tc.desc Function of API, too long path. 2227 */ 2228 it('File_rmdir_006', 0, async function (done) { 2229 let firstPath = randomString(255); 2230 let uri = 'internal://cache/' + firstPath; 2231 file.mkdir({ 2232 uri: uri, 2233 success: function () { 2234 console.info('File_rmdir_006 mkdir success'); 2235 file.rmdir({ 2236 uri: uri, 2237 success: function () { 2238 console.info('File_rmdir_006 rmdir success'); 2239 done(); 2240 }, 2241 fail: function (data, code) { 2242 console.info('File_rmdir_006 rmdir fail, code: ' + code + ', data: ' + data); 2243 expect(null).assertFail(); 2244 }, 2245 }); 2246 }, 2247 fail: function (data, code) { 2248 console.info('File_rmdir_006 mkdir fail, code: ' + code + ', data: ' + data); 2249 expect(null).assertFail(); 2250 }, 2251 }); 2252 }); 2253 2254 /** 2255 * @tc.number SUB_STORAGE_File_rmdir_0700 2256 * @tc.name File_rmdir_007 2257 * @tc.desc Function of API, cache path.The test dir is exist, and it can be delete, it is empty. 2258 */ 2259 it('File_rmdir_007', 0, async function (done) { 2260 file.mkdir({ 2261 uri: 'internal://cache/File_rmdir_007d', 2262 success: function () { 2263 console.info('File_rmdir_007 mkdir success'); 2264 file.rmdir({ 2265 uri: 'internal://cache/File_rmdir_007d', 2266 success: function () { 2267 console.info('File_rmdir_007 rmdir success'); 2268 done(); 2269 }, 2270 fail: function (data, code) { 2271 console.info('File_rmdir_007 rmdir fail, code: ' + code + ', data: ' + data); 2272 expect(null).assertFail(); 2273 }, 2274 }); 2275 }, 2276 fail: function (data, code) { 2277 console.info('File_rmdir_007 mkdir fail, code: ' + code + ', data: ' + data); 2278 expect(null).assertFail(); 2279 }, 2280 }); 2281 }); 2282 2283 /** 2284 * @tc.number SUB_STORAGE_File_rmdir_0800 2285 * @tc.name File_rmdir_008 2286 * @tc.desc Function of API, virtual path.The test dir is exist. 2287 */ 2288 it('File_rmdir_008', 0, async function (done) { 2289 file.mkdir({ 2290 uri: 'internal://cache/../files/File_rmdir_008', 2291 success: function () { 2292 console.info('File_rmdir_008 call mkdir success.'); 2293 file.rmdir({ 2294 uri: 'internal://cache/../files/File_rmdir_008', 2295 success: function () { 2296 console.info('File_rmdir_008 call rmdir success.'); 2297 done(); 2298 }, 2299 fail: function (data, code) { 2300 console.info('File_rmdir_008 rmdir fail, code: ' + code + ', data: ' + data); 2301 expect(null).assertFail(); 2302 }, 2303 }); 2304 }, 2305 fail: function (data, code) { 2306 console.info('File_rmdir_008 mkdir fail, code: ' + code + ', data: ' + data); 2307 expect(null).assertFail(); 2308 }, 2309 }); 2310 }); 2311 2312 /** 2313 * @tc.number SUB_STORAGE_File_rmdir_1000 2314 * @tc.name File_rmdir_010 2315 * @tc.desc Function of API, out of package, Virtual path, save the dir authority.The test dir is exist. 2316 */ 2317 it('File_rmdir_010', 0, async function (done) { 2318 file.rmdir({ 2319 uri: 'internal://app/../../com.ohos.systemui', 2320 success: function () { 2321 console.info('File_rmdir_010 call rmdir success.'); 2322 expect(null).assertFail(); 2323 }, 2324 fail: function (data, code) { 2325 console.info('File_rmdir_010 call rmdir callback fail, code: ' + code + ', data: ' + data); 2326 expect(code == 301).assertTrue(); 2327 done(); 2328 }, 2329 complete: function () { 2330 console.info('rmdir completed'); 2331 } 2332 }); 2333 }); 2334 2335 /** 2336 * @tc.number SUB_STORAGE_File_Move_0100 2337 * @tc.name File_Move_001 2338 * @tc.desc Function of API, move.The test file is exist. 2339 */ 2340 it('File_Move_001', 0, async function (done) { 2341 file.writeText({ 2342 uri: 'internal://cache/File_Move_001', 2343 text: 'Text that just for test.', 2344 success: function () { 2345 console.info('File_Move_001 call writeText success.'); 2346 file.move({ 2347 srcUri: 'internal://cache/File_Move_001', 2348 dstUri: 'internal://cache/File_Move_001_1', 2349 success: function (data) { 2350 console.info('File_Move_001 call writeText success. data:' + data); 2351 done(); 2352 }, 2353 fail: function (data, code) { 2354 console.info('File_Move_001 move fail, code: ' + code + ', data: ' + data); 2355 expect(null).assertFail(); 2356 }, 2357 }); 2358 }, 2359 fail: function (data, code) { 2360 console.error('File_Move_001 call writeText fail, code: ' + code + ', data: ' + data); 2361 expect(null).assertFail(); 2362 }, 2363 }); 2364 }); 2365 2366 /** 2367 * @tc.number SUB_STORAGE_File_Move_0200 2368 * @tc.name File_Move_002 2369 * @tc.desc Function of API, document integrity.The test file is exist. 2370 */ 2371 it('File_Move_002', 0, async function (done) { 2372 let typeArray = new Array('.txt', '.ppt', '.flac', '.mp4', '.so', '.zip'); 2373 let dpath = await fileName('cache'); 2374 fileio.mkdirSync(dpath); 2375 for (let i = 0; i < typeArray.length; i++) { 2376 let srcFpath = await fileName('File_Move_002') + typeArray[i]; 2377 let dstFpath = await cacheFileName('File_Move_002') + typeArray[i]; 2378 expect(prepareEmptyFile(srcFpath)).assertTrue(); 2379 file.move({ 2380 srcUri: 'internal://cache/../files/File_Move_002' + typeArray[i], 2381 dstUri: 'internal://cache/../files/cache/File_Move_002' + typeArray[i], 2382 success: function (uri) { 2383 console.info('File_Move_002 call move success. uri: ' + uri); 2384 done(); 2385 }, 2386 fail: function (data, code) { 2387 console.info('File_Move_002 , code: ' + code + ', data: ' + data); 2388 expect(null).assertFail(); 2389 }, 2390 }); 2391 } 2392 }); 2393 2394 /** 2395 * @tc.number SUB_STORAGE_File_Move_0300 2396 * @tc.name File_Move_003 2397 * @tc.desc Function of API, different size file.The test file is exist. 2398 */ 2399 it('File_Move_003', 0, async function (done) { 2400 let srcFpath = await fileName('File_Move_003'); 2401 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2402 let dstFpath = await cacheFileName('File_Move_003'); 2403 let srcUri = 'internal://cache/../files/File_Move_003'; 2404 let dstUri = 'internal://app/cache/File_Move_003'; 2405 file.move({ 2406 srcUri: srcUri, 2407 dstUri: dstUri, 2408 success: function () { 2409 console.info('File_Move_003 call move success.'); 2410 done(); 2411 }, 2412 fail: function (data, code) { 2413 console.info('File_Move_003 , code: ' + code + ', data: ' + data); 2414 expect(null).assertFail(); 2415 }, 2416 }); 2417 }); 2418 2419 /** 2420 * @tc.number SUB_STORAGE_File_Move_0400 2421 * @tc.name File_Move_004 2422 * @tc.desc Function of API, error code: 202.The test file is exist. 2423 */ 2424 it('File_Move_004', 0, async function (done) { 2425 let srcFpath = await fileName('File_Move_004'); 2426 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2427 file.move({ 2428 srcUri: 'internal://app/File_Move_004', 2429 dstUri: null, 2430 success: function () { 2431 console.info('File_Move_004 call move success.'); 2432 expect(null).assertFail(); 2433 }, 2434 fail: function (data, code) { 2435 console.info('File_Move_004 , code: ' + code + ', data: ' + data); 2436 expect(code == 202).assertTrue(); 2437 done(); 2438 }, 2439 }); 2440 }); 2441 2442 /** 2443 * @tc.number SUB_STORAGE_File_Move_0500 2444 * @tc.name File_Move_005 2445 * @tc.desc Function of API, error code: 300.The test file is exist. 2446 */ 2447 it('File_Move_005', 0, async function (done) { 2448 let srcDpath = await fileName('File_Move_005d'); 2449 fileio.mkdirSync(srcDpath); 2450 file.move({ 2451 srcUri: 'internal://cache/../files/File_Move_005d', 2452 dstUri: 'internal://app/cache/File_Move_005d', 2453 success: function () { 2454 console.info('File_Move_005 call move success.'); 2455 done(); 2456 }, 2457 fail: function (data, code) { 2458 console.info('File_Move_005 , code: ' + code + ', data: ' + data); 2459 expect(null).assertFail(); 2460 }, 2461 }); 2462 }); 2463 2464 /** 2465 * @tc.number SUB_STORAGE_File_Move_0600 2466 * @tc.name File_Move_006 2467 * @tc.desc Function of API, error code: 301.The test file is not exist. 2468 */ 2469 it('File_Move_006', 0, async function (done) { 2470 let dstUri = await fileName('File_Move_006'); 2471 expect(prepareFile(dstUri, FILE_CONTENT)).assertTrue(); 2472 file.move({ 2473 srcUri: 'internal://app/File_Move', 2474 dstUri: 'internal://app/File_Move_006', 2475 success: function () { 2476 console.info('File_Move_006 call move success.'); 2477 expect(null).assertFail(); 2478 }, 2479 fail: function (data, code) { 2480 console.info('File_Move_006 , code: ' + code + ', data: ' + data); 2481 expect(code == 301).assertTrue(); 2482 done(); 2483 }, 2484 }); 2485 }); 2486 2487 /** 2488 * @tc.number SUB_STORAGE_File_Move_0700 2489 * @tc.name File_Move_007 2490 * @tc.desc Function of API, uri more too long. 2491 */ 2492 it('File_Move_007', 0, async function (done) { 2493 let firstPath = randomString(32); 2494 let dpath = await fileName(firstPath); 2495 let uri = 'internal://app/' + firstPath; 2496 fileio.mkdirSync(dpath); 2497 for (let i = 0; i < 16; i++) { 2498 console.info('time' + i); 2499 let sonPath = randomString(251); 2500 uri = uri + '/f' + sonPath; 2501 } 2502 file.move({ 2503 srcUri: uri, 2504 dstUri: 'internal://cache/File_Move_007', 2505 success: function () { 2506 console.info('File_Move_007 => move success'); 2507 expect(null).assertFail(); 2508 }, 2509 fail: function (data, code) { 2510 console.info('File_Move_007 => move fail'); 2511 expect(code == 300).assertTrue(); 2512 done(); 2513 }, 2514 }); 2515 fileio.rmdirSync(dpath); 2516 }); 2517 2518 /** 2519 * @tc.number SUB_STORAGE_File_Move_0800 2520 * @tc.name File_Move_008 2521 * @tc.desc Function of API, cache path.The test file is exist. 2522 */ 2523 it('File_Move_008', 0, async function (done) { 2524 file.writeText({ 2525 uri: 'internal://cache/File_Move_008', 2526 text: 'sss', 2527 success: function () { 2528 console.info('File_Move_008 writeText success '); 2529 file.move({ 2530 srcUri: 'internal://cache/File_Move_008', 2531 dstUri: 'internal://app/File_Move_008', 2532 success: function (uri) { 2533 console.info('File_Move_008 move pass, uri:' + uri); 2534 file.delete({ 2535 uri: 'internal://app/File_Move_008', 2536 success: function () { 2537 console.info('File_Move_008 delete success'); 2538 done(); 2539 }, 2540 fail: function (data, code) { 2541 console.info('File_Move_008 delete fail, code: ' + code + ', data: ' + data); 2542 expect(null).assertFail(); 2543 }, 2544 }); 2545 }, 2546 fail: function (data, code) { 2547 console.info('File_Move_008 move fail, code: ' + code + ', data: ' + data); 2548 expect(null).assertFail(); 2549 }, 2550 }); 2551 }, 2552 fail: function (data, code) { 2553 console.info('File_Move_008 writeText fail, code: ' + code + ', data: ' + data); 2554 expect(null).assertFail(); 2555 }, 2556 }); 2557 }); 2558 2559 /** 2560 * @tc.number SUB_STORAGE_File_Move_0900 2561 * @tc.name File_Move_009 2562 * @tc.desc Function of API, same path. 2563 */ 2564 it('File_Move_009', 0, async function (done) { 2565 let srcFpath = await fileName('File_Move_009'); 2566 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2567 file.move({ 2568 srcUri: 'internal://app/File_Move_009', 2569 dstUri: 'internal://app/File_Move_009', 2570 success: function (data) { 2571 console.info('File_Move_009 => pass'); 2572 done(); 2573 }, 2574 fail: function (data, code) { 2575 console.info('File_Move_009 call move fail, code: ' + code + ', data: ' + data); 2576 expect(null).assertFail(); 2577 }, 2578 }); 2579 }); 2580 2581 /** 2582 * @tc.number SUB_STORAGE_File_Move_1000 2583 * @tc.name File_Move_010 2584 * @tc.desc Function of API, dstFpath has same file. 2585 */ 2586 it('File_Move_010', 0, async function (done) { 2587 let srcFpath = await fileName('File_Move_010'); 2588 let dstFpath = await cacheFileName('File_Move_010'); 2589 expect(prepareFile(srcFpath, 'aaa')).assertTrue(); 2590 expect(prepareFile(dstFpath, 'bbb')).assertTrue(); 2591 file.move({ 2592 srcUri: 'internal://app/File_Move_010', 2593 dstUri: 'internal://app/cache/File_Move_010', 2594 success: function (data) { 2595 console.info('File_Move_010 => pass'); 2596 expect(null).assertFail(); 2597 }, 2598 fail: function (data, code) { 2599 console.info('File_Move_010 , code: ' + code + ', data: ' + data); 2600 expect(code == 300).assertTrue(); 2601 done(); 2602 }, 2603 }); 2604 }); 2605 2606 /** 2607 * @tc.number SUB_STORAGE_File_Move_1100 2608 * @tc.name File_Move_011 2609 * @tc.desc Function of API, move app path file to cache path. 2610 */ 2611 it('File_Move_011', 0, async function (done) { 2612 let srcFpath = await fileName('File_Move_011'); 2613 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2614 file.move({ 2615 srcUri: 'internal://cache/../files/File_Move_011', 2616 dstUri: 'internal://cache/File_Move_011', 2617 success: function (uri) { 2618 console.info('File_Move_011 => pass, uri' + uri); 2619 done(); 2620 }, 2621 fail: function (data, code) { 2622 console.info('File_Move_011 , code: ' + code + ', data: ' + data); 2623 expect(null).assertFail(); 2624 }, 2625 }); 2626 }); 2627 2628 /** 2629 * @tc.number SUB_STORAGE_File_Move_1200 2630 * @tc.name File_Move_012 2631 * @tc.desc Function of API, out of package, Virtual path(create and give 777 authority). 2632 */ 2633 it('File_Move_012', 0, async function (done) { 2634 let srcFpath = await fileName('File_Move_012'); 2635 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2636 file.move({ 2637 srcUri: 'internal://app/../files/File_Move_012', 2638 dstUri: 'internal://app/notdir/File_Move_012', 2639 success: function (uri) { 2640 console.info('File_Move_012 => pass, uri' + uri); 2641 expect(null).assertFail(); 2642 }, 2643 fail: function (data, code) { 2644 console.info('File_Move_012 , code: ' + code + ', data: ' + data); 2645 expect(code == 300).assertTrue(); 2646 done(); 2647 }, 2648 }); 2649 }); 2650 2651 /** 2652 * @tc.number SUB_STORAGE_File_Move_1400 2653 * @tc.name File_Move_014 2654 * @tc.desc Function of API, check back value. 2655 */ 2656 it('File_Move_014', 0, async function (done) { 2657 let srcFpath = await fileName('File_Move_014'); 2658 let dstFpath = await cacheFileName('File_Move_014'); 2659 expect(prepareFile(srcFpath, 'test')).assertTrue(); 2660 let dstUri = 'internal://cache/File_Move_014'; 2661 file.move({ 2662 srcUri: 'internal://cache/../files/File_Move_014', 2663 dstUri: dstUri, 2664 success: function (uri) { 2665 console.info('File_Move_014 move pass'); 2666 done(); 2667 }, 2668 fail: function (data, code) { 2669 console.info('File_Move_014 => fail , code: ' + code + ', data: ' + data); 2670 expect(null).assertFail(); 2671 }, 2672 complete: function () { 2673 console.info('move completed'); 2674 } 2675 }); 2676 }); 2677 2678 /** 2679 * @tc.number SUB_STORAGE_File_Copy_0100 2680 * @tc.name File_Copy_001 2681 * @tc.desc Function of API, copy, app path.The test file is exist. 2682 */ 2683 it('File_Copy_001', 0, async function (done) { 2684 let srcFpath = await fileName('File_Copy_001'); 2685 let dstFpath = await cacheFileName('File_Copy_001'); 2686 expect(prepareFile(srcFpath, 'test.')).assertTrue(); 2687 file.copy({ 2688 srcUri: 'internal://cache/../files/File_Copy_001', 2689 dstUri: 'internal://cache/../files/cache/File_Copy_001', 2690 success: function () { 2691 console.info('File_Copy_001 call copy success.'); 2692 file.readText({ 2693 uri: 'internal://cache/../files/cache/File_Copy_001', 2694 success: function (data) { 2695 console.info('File_Copy_001 read success:' ); 2696 fileio.unlinkSync(srcFpath); 2697 fileio.unlinkSync(dstFpath); 2698 done(); 2699 }, 2700 fail: function (data, code) { 2701 console.info('File_Copy_001 readText fail, code: ' + code + ', data: ' + data); 2702 expect(null).assertFail(); 2703 }, 2704 }); 2705 }, 2706 fail: function (data, code) { 2707 console.info('File_Copy_001 copy fail, code: ' + code + ', data: ' + data); 2708 expect(null).assertFail(); 2709 }, 2710 }); 2711 }); 2712 2713 /** 2714 * @tc.number SUB_STORAGE_File_Copy_0200 2715 * @tc.name File_Copy_002 2716 * @tc.desc Function of API, document integrity.The test file is exist. 2717 */ 2718 it('File_Copy_002', 0, async function (done) { 2719 let typeArray = new Array('.txt', '.ppt', '.flac', '.mp4', '.so', '.zip'); 2720 for (let i = 0; i < typeArray.length; i++) { 2721 let srcFpath = await fileName('File_Copy_002') + typeArray[i]; 2722 let dstFpath = await cacheFileName('File_Copy_002') + typeArray[i]; 2723 expect(prepareEmptyFile(srcFpath)).assertTrue(); 2724 file.copy({ 2725 srcUri: 'internal://cache/../files/File_Copy_002' + typeArray[i], 2726 dstUri: 'internal://cache/../files/cache/File_Copy_002' + typeArray[i], 2727 success: function () { 2728 console.info('File_Copy_002 call copy success.'); 2729 file.delete('internal://cache/../files/File_Copy_002' + typeArray[i]); 2730 file.delete('internal://cache/../files/cache/File_Copy_002' + typeArray[i]); 2731 done(); 2732 }, 2733 fail: function (data, code) { 2734 console.info('File_Copy_002 , code: ' + code + ', data: ' + data); 2735 expect(null).assertFail(); 2736 }, 2737 }); 2738 } 2739 }); 2740 2741 /** 2742 * @tc.number SUB_STORAGE_File_Copy_0300 2743 * @tc.name File_Copy_003 2744 * @tc.desc Function of API, different size of files. The test file is exist. 2745 */ 2746 it('File_Copy_003', 0, async function (done) { 2747 let srcFpath = await fileName('File_Copy_003'); 2748 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2749 let dstFpath = await cacheFileName('File_Copy_003'); 2750 file.copy({ 2751 srcUri: 'internal://cache/../files/File_Copy_003', 2752 dstUri: 'internal://cache/../files/cache/File_Copy_003', 2753 success: function () { 2754 console.info('File_Copy_003 call copy success.'); 2755 file.readText({ 2756 uri: 'internal://cache/../files/cache/File_Copy_003', 2757 success: function (data) { 2758 console.info('File_Copy_003 readText success, data.text:'); 2759 fileio.unlinkSync(srcFpath); 2760 fileio.unlinkSync(dstFpath); 2761 done(); 2762 }, 2763 fail: function (data, code) { 2764 console.info('File_Copy_003 readText fail, code: ' + code + ', data: ' + data); 2765 expect(null).assertFail(); 2766 }, 2767 }); 2768 }, 2769 fail: function (data, code) { 2770 console.info('File_Copy_003 copy fail, code: ' + code + ', data: ' + data); 2771 expect(null).assertFail(); 2772 }, 2773 }); 2774 }); 2775 2776 /** 2777 * @tc.number SUB_STORAGE_File_Copy_0400 2778 * @tc.name File_Copy_004 2779 * @tc.desc Function of API, error code: 202 The test file is exist. 2780 */ 2781 it('File_Copy_004', 0, async function (done) { 2782 let srcFpath = await fileName('File_Copy_004'); 2783 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2784 file.copy({ 2785 srcUri: 'internal://app/File_Copy_004', 2786 dstUri: null, 2787 success: function () { 2788 console.info('File_Copy_004 call copy success.'); 2789 expect(null).assertFail(); 2790 }, 2791 fail: function (data, code) { 2792 console.info('File_Copy_004 , code: ' + code + ', data: ' + data); 2793 expect(code == 202).assertTrue(); 2794 fileio.unlinkSync(srcFpath); 2795 done(); 2796 }, 2797 }); 2798 }); 2799 2800 /** 2801 * @tc.number SUB_STORAGE_File_Copy_0500 2802 * @tc.name File_Copy_005 2803 * @tc.desc Function of API, error code: 300 2804 */ 2805 2806 it('File_Copy_005', 0, async function (done) { 2807 file.mkdir({ 2808 uri: 'internal://cache/File_Copy_005d', 2809 success: function () { 2810 console.info('File_Copy_005 call mkdir success.'); 2811 file.copy({ 2812 srcUri: 'internal://cache/File_Copy_005d', 2813 dstUri: 'internal://cache/File_Copy_005d_1', 2814 success: function () { 2815 console.info('File_Copy_005 call copy success.'); 2816 done(); 2817 }, 2818 fail: function (data, code) { 2819 console.info('File_Copy_005 , code: ' + code + ', data: ' + data); 2820 expect(null).assertFail(); 2821 }, 2822 }); 2823 }, 2824 fail: function (data, code) { 2825 console.error('File_Copy_005 call mkdir fail, code: ' + code + ', data: ' + data); 2826 expect(null).assertFail(); 2827 }, 2828 }); 2829 }); 2830 2831 /** 2832 * @tc.number SUB_STORAGE_File_Copy_0600 2833 * @tc.name File_Copy_006 2834 * @tc.desc Function of API, error code: 301 2835 */ 2836 it('File_Copy_006', 0, async function (done) { 2837 file.copy({ 2838 srcUri: 'internal://app/fakepath', 2839 dstUri: 'internal://app/fakepath1', 2840 success: function () { 2841 console.info('File_Copy_006 call copy success.'); 2842 expect(null).assertFail(); 2843 }, 2844 fail: function (data, code) { 2845 console.info('File_Copy_006 , code: ' + code + ', data: ' + data); 2846 expect(code == 301).assertTrue(); 2847 done(); 2848 }, 2849 }); 2850 }); 2851 2852 /** 2853 * @tc.number SUB_STORAGE_File_Copy_0700 2854 * @tc.name File_Copy_007 2855 * @tc.desc Function of API, uri too long. 2856 */ 2857 it('File_Copy_007', 0, async function (done) { 2858 let firstPath = randomString(32); 2859 let dpath = await fileName(firstPath); 2860 let uri = 'internal://cache/' + firstPath; 2861 fileio.mkdirSync(dpath); 2862 for (let i = 0; i < 16; i++) { 2863 console.info('time' + i); 2864 let sonPath = randomString(251); 2865 uri = uri + '/f' + sonPath; 2866 } 2867 file.copy({ 2868 srcUri: uri, 2869 dstUri: uri, 2870 success: function () { 2871 console.info('File_Copy_007 => copy success'); 2872 expect(null).assertFail(); 2873 }, 2874 fail: function (data, code) { 2875 console.info('File_Copy_007 => fail, code: ' + code + ', data: ' + data); 2876 fileio.rmdirSync(dpath); 2877 expect(code == 300).assertTrue(); 2878 done(); 2879 }, 2880 }); 2881 }); 2882 2883 /** 2884 * @tc.number SUB_STORAGE_File_Copy_0800 2885 * @tc.name File_Copy_008 2886 * @tc.desc Function of API, cache path. 2887 */ 2888 it('File_Copy_008', 0, async function (done) { 2889 file.writeText({ 2890 uri: 'internal://cache/File_Copy_008', 2891 text: 'test', 2892 success: function () { 2893 console.info('File_Copy_008 mkdir success'); 2894 file.copy({ 2895 srcUri: 'internal://cache/File_Copy_008', 2896 dstUri: 'internal://cache/../files/File_Copy_008', 2897 success: function () { 2898 console.info('File_Copy_008 copy success'); 2899 file.delete({ 2900 uri: 'internal://cache/../files/File_Copy_008', 2901 success: function () { 2902 console.info('File_Copy_008 delete success '); 2903 file.delete({ 2904 uri: 'internal://cache/File_Copy_008', 2905 success: function () { 2906 console.info('File_Copy_008 delete success'); 2907 done(); 2908 }, 2909 fail: function (data, code) { 2910 console.info('File_Copy_008 cache delete fail, code: ' + code + ', data: ' + data); 2911 expect(null).assertFail(); 2912 }, 2913 }); 2914 }, 2915 fail: function (data, code) { 2916 console.info('File_Copy_008 files delete fail, code: ' + code + ', data: ' + data); 2917 expect(null).assertFail(); 2918 }, 2919 }); 2920 }, 2921 fail: function (data, code) { 2922 console.info('File_Copy_008 copy fail, code: ' + code + ', data: ' + data); 2923 expect(null).assertFail(); 2924 }, 2925 }); 2926 }, 2927 fail: function (data, code) { 2928 console.info('File_Copy_008 writeText fail, code: ' + code + ', data: ' + data); 2929 expect(null).assertFail(); 2930 }, 2931 }); 2932 }); 2933 2934 /** 2935 * @tc.number SUB_STORAGE_File_Copy_0900 2936 * @tc.name File_Copy_009 2937 * @tc.desc Function of API, same path. 2938 */ 2939 it('File_Copy_009', 0, async function (done) { 2940 let srcFpath = await fileName('File_Copy_009'); 2941 expect(prepareFile(srcFpath, FILE_CONTENT)).assertTrue(); 2942 file.copy({ 2943 srcUri: 'internal://app/File_Copy_009', 2944 dstUri: 'internal://app/File_Copy_009', 2945 success: function (data) { 2946 console.info('File_Copy_009 => pass'); 2947 fileio.unlinkSync(srcFpath); 2948 done(); 2949 }, 2950 fail: function (data, code) { 2951 console.info('File_Copy_009 , code: ' + code + ', data: ' + data); 2952 expect(null).assertFail(); 2953 }, 2954 }); 2955 }); 2956 2957 /** 2958 * @tc.number SUB_STORAGE_File_Copy_1000 2959 * @tc.name File_Copy_010 2960 * @tc.desc Function of API, dstFpath path has same file. 2961 */ 2962 it('File_Copy_010', 0, async function (done) { 2963 let srcFpath = await fileName('File_Copy_010'); 2964 let dstFpath = await cacheFileName('File_Copy_010'); 2965 expect(prepareFile(srcFpath, 'aaa')).assertTrue(); 2966 expect(prepareFile(dstFpath, 'bbb')).assertTrue(); 2967 file.copy({ 2968 srcUri: 'internal://app/File_Copy_010', 2969 dstUri: 'internal://app/cache/File_Copy_010', 2970 success: function (data) { 2971 console.info('File_Copy_010 => pass'); 2972 expect(null).assertFail(); 2973 }, 2974 fail: function (data, code) { 2975 console.info('File_Copy_010 , code: ' + code + ', data: ' + data); 2976 console.info("code::" + code); 2977 expect(code == 300).assertTrue(); 2978 fileio.unlinkSync(srcFpath); 2979 fileio.unlinkSync(dstFpath); 2980 done(); 2981 }, 2982 }); 2983 }); 2984 2985 /** 2986 * @tc.number SUB_STORAGE_File_Copy_1100 2987 * @tc.name File_Copy_011 2988 * @tc.desc Function of API, copy file to cache path.The test file is exist. 2989 */ 2990 it('File_Copy_011', 0, async function (done) { 2991 let srcFpath = await fileName('File_Copy_011'); 2992 expect(prepareFile(srcFpath, 'test.')).assertTrue(); 2993 file.copy({ 2994 srcUri: 'internal://cache/../files/File_Copy_011', 2995 dstUri: 'internal://cache/File_Copy_011', 2996 success: function () { 2997 console.info('File_Copy_011 copy pass'); 2998 file.readText({ 2999 uri: 'internal://cache/File_Copy_011', 3000 success: function (data) { 3001 console.info('File_Copy_011 read success:' ); 3002 done(); 3003 }, 3004 fail: function (data, code) { 3005 console.info('File_Copy_011 readText fail, code: ' + code + ', data: ' + data); 3006 expect(null).assertFail(); 3007 }, 3008 }); 3009 }, 3010 fail: function (data, code) { 3011 console.info('File_Copy_011 copy fail, code: ' + code + ', data: ' + data); 3012 expect(null).assertFail(); 3013 }, 3014 }); 3015 }); 3016 3017 /** 3018 * @tc.number SUB_STORAGE_File_Copy_1200 3019 * @tc.name File_Copy_012 3020 * @tc.desc Function of API, out of package, Virtual path(create and give 777 authority).The test file is exist. 3021 */ 3022 it('File_Copy_012', 0, async function (done) { 3023 let srcFpath = await fileName('File_Copy_012'); 3024 expect(prepareFile(srcFpath, 'test')).assertTrue(); 3025 file.copy({ 3026 srcUri: 'internal://app/../files/File_Copy_012', 3027 dstUri: 'internal://app/notdir/File_Move_012', 3028 success: function () { 3029 console.info('File_Copy_012 copy pass'); 3030 expect(null).assertFail(); 3031 }, 3032 fail: function (data, code) { 3033 console.info('File_Copy_012 , code: ' + code + ', data: ' + data); 3034 expect(code == 300).assertTrue(); 3035 fileio.unlinkSync(srcFpath); 3036 done(); 3037 }, 3038 }); 3039 }); 3040 3041 /** 3042 * @tc.number SUB_STORAGE_File_Copy_1400 3043 * @tc.name File_Copy_014 3044 * @tc.desc Function of API, check back value.The test file is exist. 3045 */ 3046 3047 it('File_Copy_014', 0, async function (done) { 3048 let srcFpath = await fileName('File_Copy_014'); 3049 let dstFpath = await cacheFileName('File_Copy_014'); 3050 expect(prepareFile(srcFpath, 'test')).assertTrue(); 3051 let dstUri = 'internal://cache/File_Copy_014'; 3052 file.copy({ 3053 srcUri: 'internal://cache/../files/File_Copy_014', 3054 dstUri: dstUri, 3055 success: function (uri) { 3056 console.info('File_Copy_014 copy pass'); 3057 done(); 3058 }, 3059 fail: function (data, code) { 3060 console.info('File_Copy_014 => fail , code: ' + code + ', data: ' + data); 3061 expect(null).assertFail(); 3062 }, 3063 complete: function () { 3064 console.info('copy completed'); 3065 } 3066 }); 3067 }); 3068 3069 /** 3070 * @tc.number SUB_STORAGE_File_List_0100 3071 * @tc.name File_List_001 3072 * @tc.desc Function of API, list.The test file and dir are exist. 3073 */ 3074 it('File_List_001', 0, async function (done) { 3075 let dpath = await fileName('File_List_001') + 'd'; 3076 let fpath = dpath + '/File_List_001'; 3077 let ddpath = dpath + '/File_List_001_1d'; 3078 fileio.mkdirSync(dpath); 3079 fileio.mkdirSync(ddpath); 3080 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3081 file.list({ 3082 uri: 'internal://cache/../files/File_List_001d', 3083 success: function (data) { 3084 console.info('File_List_001 call list success.' + JSON.stringify(data.fileList)); 3085 fileio.unlinkSync(fpath); 3086 fileio.rmdirSync(ddpath); 3087 fileio.rmdirSync(dpath); 3088 done(); 3089 }, 3090 fail: function (data, code) { 3091 console.info('File_List_001 , code: ' + code + ', data: ' + data); 3092 expect(null).assertFail(); 3093 }, 3094 }); 3095 }); 3096 3097 /** 3098 * @tc.number SUB_STORAGE_File_List_0200 3099 * @tc.name File_List_002 3100 * @tc.desc Function of API, set value of uri.The test file and dir are exist. 3101 */ 3102 it('File_List_002', 0, async function (done) { 3103 let dpath = await fileName('File_List_002') + 'd'; 3104 let fpath = dpath + '/File_List_002'; 3105 let ddpath = dpath + '/File_List_002_1d'; 3106 fileio.mkdirSync(dpath); 3107 fileio.mkdirSync(ddpath); 3108 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3109 file.list({ 3110 uri: 'internal://cache/../files/File_List_002d', 3111 success: function (data) { 3112 console.info('File_List_002 call list success.' + JSON.stringify(data.fileList)); 3113 fileio.unlinkSync(fpath); 3114 fileio.rmdirSync(ddpath); 3115 fileio.rmdirSync(dpath); 3116 done(); 3117 }, 3118 fail: function (data, code) { 3119 console.info('File_List_002 , code: ' + code + ', data: ' + data); 3120 expect(null).assertFail(); 3121 }, 3122 }); 3123 }); 3124 3125 /** 3126 * @tc.number SUB_STORAGE_File_List_0300 3127 * @tc.name File_List_003 3128 * @tc.desc Function of API, check lastModifiedTime.The test file and dir are exist. 3129 */ 3130 it('File_List_003', 0, async function (done) { 3131 let dpath = await fileName('File_List_003') + 'd'; 3132 let fpath = dpath + '/File_List_003'; 3133 let ddpath = dpath + '/File_List_003_1d'; 3134 fileio.mkdirSync(dpath); 3135 fileio.mkdirSync(ddpath); 3136 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3137 file.list({ 3138 uri: 'internal://cache/../files/File_List_003d', 3139 success: function (data) { 3140 console.info('File_List_003 call list success.' + JSON.stringify(data.fileList)); 3141 done(); 3142 }, 3143 fail: function (data, code) { 3144 console.info('File_List_003 , code: ' + code + ', data: ' + data); 3145 expect(null).assertFail(); 3146 }, 3147 }); 3148 file.writeText({ 3149 uri: 'internal://cache/../files/File_List_003d/File_List_003', 3150 text: '1', 3151 success: function (data) { 3152 console.info('File_List_003 call write success.'); 3153 done(); 3154 }, 3155 fail: function (data, code) { 3156 console.info('File_List_003 , code: ' + code + ', data: ' + data); 3157 expect(null).assertFail(); 3158 }, 3159 }); 3160 file.list({ 3161 uri: 'internal://cache/../files/File_List_003d', 3162 success: function (data) { 3163 console.info('File_List_003 call list success.' + JSON.stringify(data.fileList)); 3164 fileio.unlinkSync(fpath); 3165 fileio.rmdirSync(ddpath); 3166 fileio.rmdirSync(dpath); 3167 done(); 3168 }, 3169 fail: function (data, code) { 3170 console.info('File_List_003 , code: ' + code + ', data: ' + data); 3171 expect(null).assertFail(); 3172 }, 3173 }); 3174 }); 3175 3176 /** 3177 * @tc.number SUB_STORAGE_File_List_0400 3178 * @tc.name File_List_004 3179 * @tc.desc Function of API, check length.The test file and dir are exist. 3180 */ 3181 it('File_List_004', 0, async function (done) { 3182 let dpath = await fileName('File_List_004') + 'd'; 3183 let fpath = dpath + '/File_List_004'; 3184 let ddpath = dpath + '/File_List_004_1d'; 3185 fileio.mkdirSync(dpath); 3186 fileio.mkdirSync(ddpath); 3187 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3188 file.list({ 3189 uri: 'internal://cache/../files/File_List_004d', 3190 success: function (data) { 3191 console.info('File_List_004 call list success.'); 3192 done(); 3193 }, 3194 fail: function (data, code) { 3195 console.info('File_List_004 , code: ' + code + ', data: ' + data); 3196 expect(null).assertFail(); 3197 }, 3198 }); 3199 }); 3200 3201 /** 3202 * @tc.number SUB_STORAGE_File_List_0500 3203 * @tc.name File_List_005 3204 * @tc.desc Function of API, check type.The test file and dir are exist. 3205 */ 3206 it('File_List_005', 0, async function (done) { 3207 let dpath = await fileName('File_List_005') + 'd'; 3208 let fpath = dpath + '/File_List_005'; 3209 let ddpath = dpath + '/File_List_005_1d'; 3210 fileio.mkdirSync(dpath); 3211 fileio.mkdirSync(ddpath); 3212 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3213 file.list({ 3214 uri: 'internal://cache/../files/File_List_005d', 3215 success: function (data) { 3216 console.info('File_List_005 call list success.'); 3217 done(); 3218 }, 3219 fail: function (data, code) { 3220 console.info('File_List_005 , code: ' + code + ', data: ' + data); 3221 expect(null).assertFail(); 3222 }, 3223 }); 3224 }); 3225 3226 /** 3227 * @tc.number SUB_STORAGE_File_List_0600 3228 * @tc.name File_List_006 3229 * @tc.desc Function of API, error code:202 3230 */ 3231 it('File_List_006', 0, async function (done) { 3232 let dpath = await fileName('File_List_006') + 'd' 3233 file.list({ 3234 uri: dpath, 3235 success: function (data) { 3236 console.info('File_List_006 call list success.' + data.fileList); 3237 expect(null).assertFail(); 3238 }, 3239 fail: function (data, code) { 3240 console.info('File_List_006 , code: ' + code + ', data: ' + data); 3241 expect(code == 202).assertTrue(); 3242 done(); 3243 }, 3244 }); 3245 }); 3246 3247 /** 3248 * @tc.number SUB_STORAGE_File_List_0700 3249 * @tc.name File_List_007 3250 * @tc.desc Function of API, uri set value of file. 3251 */ 3252 it('File_List_007', 0, async function (done) { 3253 let fpath = await fileName('File_List_007'); 3254 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3255 file.list({ 3256 uri: 'internal://cache/../files/File_List_007', 3257 success: function (data) { 3258 console.info('File_List_007 pass, data.fileList:' + JSON.stringify(data.fileList)); 3259 fileio.unlinkSync(fpath); 3260 done(); 3261 }, 3262 fail: function (data, code) { 3263 console.info('File_List_007 , code: ' + code + ', data: ' + data); 3264 expect(null).assertFail(); 3265 }, 3266 }); 3267 }); 3268 3269 /** 3270 * @tc.number SUB_STORAGE_File_List_0800 3271 * @tc.name File_List_008 3272 * @tc.desc Function of API, error code: 301 3273 */ 3274 it('File_List_008', 0, async function (done) { 3275 file.list({ 3276 uri: 'internal://app/fakepath', 3277 success: function (data) { 3278 console.info('File_List_008 call list success.' + JSON.stringify(data.fileList)); 3279 expect(null).assertFail(); 3280 }, 3281 fail: function (data, code) { 3282 console.info('File_List_008 , code: ' + code + ', data: ' + data); 3283 expect(code == 301).assertTrue(); 3284 done(); 3285 }, 3286 }); 3287 }); 3288 3289 /** 3290 * @tc.number SUB_STORAGE_File_List_0900 3291 * @tc.name File_List_009 3292 * @tc.desc Function of API, uri too long. 3293 */ 3294 it('File_List_009', 0, async function (done) { 3295 let firstPath = randomString(32); 3296 let dpath = await fileName(firstPath); 3297 let uri = 'internal://app/' + firstPath; 3298 fileio.mkdirSync(dpath); 3299 for (let i = 0; i < 16; i++) { 3300 console.info('time' + i); 3301 let sonPath = randomString(251); 3302 uri = uri + '/f' + sonPath; 3303 } 3304 file.list({ 3305 uri: uri, 3306 success: function (data) { 3307 console.info('File_List_009 => pass' + data); 3308 expect(null).assertFail(); 3309 }, 3310 fail: function (data, code) { 3311 console.info('File_List_009 , code: ' + code + ', data: ' + data); 3312 expect(code == 300).assertTrue(); 3313 fileio.rmdirSync(dpath); 3314 done(); 3315 }, 3316 }); 3317 }); 3318 3319 /** 3320 * @tc.number SUB_STORAGE_File_List_1000 3321 * @tc.name File_List_010 3322 * @tc.desc Function of API, cache path.The test file and dir are exist. 3323 */ 3324 it('File_List_010', 0, async function (done) { 3325 let dpath = await nextFileName('File_List_010d'); 3326 let fpath = dpath + '/File_List_010'; 3327 let ffpath = dpath + '/File_List_010_1'; 3328 let ddpath = dpath + '/File_List_010_1d'; 3329 let fffpath = ddpath + '/File_List_010_2'; 3330 try { 3331 fileio.mkdirSync(dpath); 3332 fileio.mkdirSync(ddpath); 3333 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3334 expect(prepareFile(ffpath, FILE_CONTENT)).assertTrue(); 3335 expect(prepareFile(fffpath, FILE_CONTENT)).assertTrue(); 3336 } 3337 catch (e) { 3338 console.info('File_List_010 has failed for ' + e); 3339 expect(null).assertFail(); 3340 } 3341 file.list({ 3342 uri: 'internal://cache/File_List_010d', 3343 success: function (data) { 3344 console.info('File_List_010 => pass' + JSON.stringify(data.fileList)); 3345 fileio.unlinkSync(fpath); 3346 fileio.unlinkSync(ffpath); 3347 fileio.unlinkSync(fffpath); 3348 fileio.rmdirSync(ddpath); 3349 fileio.rmdirSync(dpath); 3350 done(); 3351 }, 3352 fail: function (data, code) { 3353 console.info('File_List_010 fail, code: ' + code + ', data: ' + data); 3354 expect(null).assertFail(); 3355 }, 3356 }); 3357 }); 3358 3359 /** 3360 * @tc.number SUB_STORAGE_File_List_1100 3361 * @tc.name File_List_011 3362 * @tc.desc Function of API, virtual path.The test dir are exist. 3363 */ 3364 it('File_List_011', 0, async function (done) { 3365 let dpath = await fileName('File_List_011') + 'd'; 3366 let fpath = dpath + '/File_List_011'; 3367 let ddpath = dpath + '/File_List_011_1d'; 3368 fileio.mkdirSync(dpath); 3369 fileio.mkdirSync(ddpath); 3370 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3371 file.list({ 3372 uri: 'internal://cache/../files/File_List_011d', 3373 success: function (data) { 3374 console.info('File_List_011 call list success.' + JSON.stringify(data.fileList)); 3375 fileio.unlinkSync(fpath); 3376 fileio.rmdirSync(ddpath); 3377 fileio.rmdirSync(dpath); 3378 done(); 3379 }, 3380 fail: function (data, code) { 3381 console.info('File_List_011 fail, code: ' + code + ', data: ' + data); 3382 expect(null).assertFail(); 3383 }, 3384 }); 3385 }); 3386 3387 /** 3388 * @tc.number SUB_STORAGE_File_List_1200 3389 * @tc.name Function of API, out of package, Virtual path(create and give 777 authority). 3390 * @tc.desc The test dir are exist. 3391 */ 3392 it('File_List_012', 0, async function (done) { 3393 file.list({ 3394 uri: 'internal://cache/../files/../../', 3395 success: function (data) { 3396 console.info('File_List_012 call list success.' + JSON.stringify(data.fileList)); 3397 done(); 3398 }, 3399 fail: function (data, code) { 3400 console.info('File_List_012 fail, code: ' + code + ', data: ' + data); 3401 expect(null).assertFail(); 3402 }, 3403 complete: function () { 3404 console.info('list completed'); 3405 } 3406 }); 3407 }); 3408 3409 /** 3410 * @tc.number SUB_STORAGE_File_Get_0100 3411 * @tc.name File_Get_001 3412 * @tc.desc Function of API, Get.The test file is exist. 3413 */ 3414 it('File_Get_001', 0, async function (done) { 3415 let fpath = await fileName('File_Get_001'); 3416 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3417 file.get({ 3418 uri: 'internal://cache/../files/File_Get_001', 3419 recursive: true, 3420 success: function (data) { 3421 console.info('File_Get_001 pass,data.uri：' ); 3422 fileio.unlinkSync(fpath); 3423 done(); 3424 }, 3425 fail: function (data, code) { 3426 console.info('File_Get_001 fail, code: ' + code + ', data: ' + data); 3427 expect(null).assertFail(); 3428 }, 3429 }); 3430 }); 3431 3432 /** 3433 * @tc.number SUB_STORAGE_File_Get_0200 3434 * @tc.name File_Get_002 3435 * @tc.desc Function of API, recursive = false.The test file is exist. 3436 */ 3437 it('File_Get_002', 0, async function (done) { 3438 let fpath = await fileName('File_Get_002'); 3439 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3440 file.get({ 3441 uri: 'internal://cache/../files/File_Get_002', 3442 recursive: false, 3443 success: function (data) { 3444 console.info('File_Get_002 => file list：'); 3445 console.info('{uri:' ); 3446 console.info('length:' + data.length); 3447 console.info('lastModifiedTime:' + data.lastModifiedTime); 3448 console.info('type:' + data.type); 3449 console.info('subFiles:' + data.subFiles + '}'); 3450 fileio.unlinkSync(fpath); 3451 done(); 3452 }, 3453 fail: function (data, code) { 3454 console.info('File_Get_002 fail, code: ' + code + ', data: ' + data); 3455 expect(null).assertFail(); 3456 }, 3457 }); 3458 }); 3459 3460 /** 3461 * @tc.number SUB_STORAGE_File_Get_0300 3462 * @tc.name File_Get_003 3463 * @tc.desc Function of API, not input recursive.The test file is exist. 3464 */ 3465 it('File_Get_003', 0, async function (done) { 3466 let fpath = await fileName('File_Get_003'); 3467 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3468 file.get({ 3469 uri: 'internal://cache/../files/File_Get_003', 3470 success: function (data) { 3471 console.info('File_Get_003 => file list：'); 3472 console.info('{uri:' ); 3473 console.info('length:' + data.length); 3474 console.info('lastModifiedTime:' + data.lastModifiedTime); 3475 console.info('type:' + data.type); 3476 console.info('subFiles:' + data.subFiles + '}'); 3477 console.info('File_Get_003 => pass'); 3478 fileio.unlinkSync(fpath); 3479 done(); 3480 }, 3481 fail: function (data, code) { 3482 console.info('File_Get_003 fail, code: ' + code + ', data: ' + data); 3483 expect(null).assertFail(); 3484 }, 3485 }); 3486 }); 3487 3488 /** 3489 * @tc.number SUB_STORAGE_File_Get_0400 3490 * @tc.name File_Get_004 3491 * @tc.desc Function of API, recursive = ture.The test file is exist. 3492 */ 3493 it('File_Get_004', 0, async function (done) { 3494 let dpath = await fileName('File_Get_004d'); 3495 let ddpath = dpath + '/File_Get_004dd' 3496 let fpath = dpath + '/File_Get_004f' 3497 let ffpath = ddpath + '/File_Get_004ff' 3498 fileio.mkdirSync(dpath); 3499 fileio.mkdirSync(ddpath); 3500 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3501 expect(prepareFile(ffpath, FILE_CONTENT)).assertTrue(); 3502 file.get({ 3503 uri: 'internal://cache/../files/File_Get_004d', 3504 recursive: true, 3505 success: function (data) { 3506 console.info('File_Get_004 => file list：'); 3507 console.info('{uri:' ); 3508 console.info('length:' + data.length); 3509 console.info('lastModifiedTime:' + data.lastModifiedTime); 3510 console.info('type:' + data.type); 3511 console.info('subFiles:' + data.subFiles + '}'); 3512 console.info('File_Get_004 => pass'); 3513 fileio.unlinkSync(ffpath); 3514 fileio.unlinkSync(fpath); 3515 fileio.rmdirSync(ddpath); 3516 fileio.rmdirSync(dpath); 3517 done(); 3518 }, 3519 fail: function (data, code) { 3520 console.info('File_Get_004 fail, code: ' + code + ', data: ' + data); 3521 expect(null).assertFail(); 3522 }, 3523 }); 3524 }); 3525 3526 /** 3527 * @tc.number SUB_STORAGE_File_Get_0500 3528 * @tc.name File_Get_005 3529 * @tc.desc Function of API, recursive = false.The test file is exist. 3530 */ 3531 it('File_Get_005', 0, async function (done) { 3532 let dpath = await fileName('File_Get_005d'); 3533 let ddpath = dpath + '/File_Get_005dd'; 3534 let fpath = dpath + '/File_Get_005f'; 3535 let ffpath = ddpath + '/File_Get_005ff'; 3536 fileio.mkdirSync(dpath); 3537 fileio.mkdirSync(ddpath); 3538 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3539 expect(prepareFile(ffpath, FILE_CONTENT)).assertTrue(); 3540 file.get({ 3541 uri: 'internal://cache/../files/File_Get_005d', 3542 recursive: false, 3543 success: function (data) { 3544 console.info('File_Get_005 => file list ：'); 3545 console.info('{uri:' ); 3546 console.info('length:' + data.length); 3547 console.info('lastModifiedTime:' + data.lastModifiedTime); 3548 console.info('type:' + data.type); 3549 console.info('subFiles:' + data.subFiles + '}'); 3550 console.info('File_Get_005 => pass'); 3551 fileio.unlinkSync(ffpath); 3552 fileio.unlinkSync(fpath); 3553 fileio.rmdirSync(ddpath); 3554 fileio.rmdirSync(dpath); 3555 done(); 3556 }, 3557 fail: function (data, code) { 3558 console.info('File_Get_005 fail, code: ' + code + ', data: ' + data); 3559 expect(null).assertFail(); 3560 }, 3561 }); 3562 }); 3563 3564 /** 3565 * @tc.number SUB_STORAGE_File_Get_0600 3566 * @tc.name File_Get_006 3567 * @tc.desc Function of API, not input recursive.The test file is exist. 3568 */ 3569 it('File_Get_006', 0, async function (done) { 3570 let dpath = await fileName('File_Get_006d'); 3571 let ddpath = dpath + '/File_Get_006dd'; 3572 let fpath = dpath + '/File_Get_006f'; 3573 let ffpath = ddpath + '/File_Get_006ff'; 3574 fileio.mkdirSync(dpath); 3575 fileio.mkdirSync(ddpath); 3576 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3577 expect(prepareFile(ffpath, FILE_CONTENT)).assertTrue(); 3578 file.get({ 3579 uri: 'internal://cache/../files/File_Get_006d', 3580 success: function (data) { 3581 console.info('File_Get_006 file list：'); 3582 console.info('{uri:' ); 3583 console.info('length:' + data.length); 3584 console.info('lastModifiedTime:' + data.lastModifiedTime); 3585 console.info('type:' + data.type); 3586 console.info('subFiles:' + data.subFiles + '}'); 3587 console.info('File_Get_006 => pass'); 3588 fileio.unlinkSync(ffpath); 3589 fileio.unlinkSync(fpath); 3590 fileio.rmdirSync(ddpath); 3591 fileio.rmdirSync(dpath); 3592 done(); 3593 }, 3594 fail: function (data, code) { 3595 console.info('File_Get_006 fail, code: ' + code + ', data: ' + data); 3596 expect(null).assertFail(); 3597 }, 3598 }); 3599 }); 3600 3601 /** 3602 * @tc.number SUB_STORAGE_File_Get_0700 3603 * @tc.name File_Get_007 3604 * @tc.desc Function of API, not input uri.The test file is exist. 3605 */ 3606 it('File_Get_007', 0, async function (done) { 3607 file.get({ 3608 recursive: true, 3609 success: function (data) { 3610 console.info('File_Get_007 call Copy success.'); 3611 expect(null).assertFail(); 3612 }, 3613 fail: function (data, code) { 3614 console.info('File_Get_007 fail, code: ' + code + ', data: ' + data); 3615 expect(code == 202).assertTrue(); 3616 done(); 3617 }, 3618 }); 3619 }); 3620 3621 /** 3622 * @tc.number SUB_STORAGE_File_Get_0800 3623 * @tc.name File_Get_008 3624 * @tc.desc Function of API, not input parameter.The test file is exist. 3625 */ 3626 it('File_Get_008', 0, async function (done) { 3627 file.get({ 3628 success: function (data) { 3629 console.info(data); 3630 expect(null).assertFail(); 3631 }, 3632 fail: function (data, code) { 3633 console.info('File_Get_008 fail, code: ' + code + ', data: ' + data); 3634 expect(code == 202).assertTrue(); 3635 done(); 3636 }, 3637 }); 3638 }); 3639 3640 /** 3641 * @tc.number SUB_STORAGE_File_Get_0900 3642 * @tc.name File_Get_009 3643 * @tc.desc Function of API, error parameter.The test file and dir are not exist. 3644 */ 3645 it('File_Get_009', 0, async function (done) { 3646 file.get({ 3647 uri: 'internal://app/File_Get_009', 3648 success: function (data) { 3649 console.info('File_Get_009 call Copy success.'); 3650 expect(null).assertFail(); 3651 }, 3652 fail: function (data, code) { 3653 console.info('File_Get_009 fail, code: ' + code + ', data: ' + data); 3654 expect(code == 301).assertTrue(); 3655 done(); 3656 }, 3657 }); 3658 }); 3659 3660 /** 3661 * @tc.number SUB_STORAGE_File_Get_1000 3662 * @tc.name File_Get_010 3663 * @tc.desc Function of API, uri = -1. 3664 */ 3665 it('File_Get_010', 0, async function (done) { 3666 file.get({ 3667 uri: -1, 3668 success: function (data) { 3669 console.info('File_Get_010 call Copy success.'); 3670 expect(null).assertFail(); 3671 }, 3672 fail: function (data, code) { 3673 console.info('File_Get_010 fail, code: ' + code + ', data: ' + data); 3674 expect(code == 202).assertTrue(); 3675 done(); 3676 }, 3677 }); 3678 }); 3679 3680 /** 3681 * @tc.number SUB_STORAGE_File_Get_1100 3682 * @tc.name File_Get_011 3683 * @tc.desc Function of API, cacahe path. 3684 */ 3685 it('File_Get_011', 0, async function (done) { 3686 file.writeText({ 3687 uri: 'internal://cache/File_Get_011', 3688 text: 'test', 3689 success: function () { 3690 console.info('File_Get_011 writeText success'); 3691 file.get({ 3692 uri: 'internal://cache/File_Get_011', 3693 recursive: true, 3694 success: function (data) { 3695 console.info('file list'); 3696 console.info('uri:' ); 3697 console.info('length:' + data.length); 3698 console.info('lastModifiedTime:' + data.lastModifiedTime); 3699 console.info('type:' + data.type); 3700 console.info('subFiles:' + data.subFiles); 3701 file.delete({ 3702 uri: 'internal://cache/File_Get_011', 3703 success: function () { 3704 console.info('File_Get_011 delete success'); 3705 done(); 3706 }, 3707 fail: function (data, code) { 3708 console.info('File_Get_011 delete fail, code: ' + code + ', data: ' + data); 3709 expect(null).assertFail(); 3710 }, 3711 }); 3712 }, 3713 fail: function (data, code) { 3714 console.info('File_Get_011 get fail, code: ' + code + ', data: ' + data); 3715 expect(null).assertFail(); 3716 }, 3717 }); 3718 }, 3719 fail: function (data, code) { 3720 console.info('File_Get_011 writeText fail, code: ' + code + ', data: ' + data); 3721 expect(null).assertFail(); 3722 }, 3723 }); 3724 }); 3725 3726 /** 3727 * @tc.number SUB_STORAGE_File_Get_1200 3728 * @tc.name File_Get_012 3729 * @tc.desc Function of API, uri too long. 3730 */ 3731 it('File_Get_012', 0, async function (done) { 3732 let firstPath = randomString(32); 3733 let dpath = await fileName(firstPath); 3734 let uri = 'internal://cache/' + firstPath; 3735 fileio.mkdirSync(dpath); 3736 for (let i = 0; i < 16; i++) { 3737 console.info('time' + i); 3738 let sonPath = randomString(251); 3739 uri = uri + '/f' + sonPath; 3740 } 3741 file.get({ 3742 uri: uri, 3743 recursive: true, 3744 success: function (data) { 3745 console.info('file list'); 3746 console.info('uri:' ); 3747 console.info('length:' + data.length); 3748 console.info('lastModifiedTime:' + data.lastModifiedTime); 3749 console.info('type:' + data.type); 3750 console.info('subFiles:' + data.subFiles); 3751 console.info('File_Get_012 => pass'); 3752 expect(null).assertFail(); 3753 }, 3754 fail: function (data, code) { 3755 console.info('File_Get_012 fail, code: ' + code + ', data: ' + data); 3756 expect(code == 300).assertTrue(); 3757 done(); 3758 }, 3759 }); 3760 }); 3761 3762 /** 3763 * @tc.number SUB_STORAGE_File_Get_1300 3764 * @tc.name File_Get_013 3765 * @tc.desc Function of API, virtual path. 3766 */ 3767 it('File_Get_013', 0, async function (done) { 3768 let dpath = await fileName('File_Get_013d'); 3769 let ddpath = dpath + '/File_Get_013dd'; 3770 let fpath = dpath + '/File_Get_013f'; 3771 let ffpath = ddpath + '/File_Get_013ff'; 3772 fileio.mkdirSync(dpath); 3773 fileio.mkdirSync(ddpath); 3774 expect(prepareFile(fpath, FILE_CONTENT)).assertTrue(); 3775 expect(prepareFile(ffpath, FILE_CONTENT)).assertTrue(); 3776 file.get({ 3777 uri: 'internal://cache/../files/../files/File_Get_013d', 3778 recursive: true, 3779 success: function (data) { 3780 console.info('File_Get_013 => file list：'); 3781 console.info('{uri:' ); 3782 console.info('length:' + data.length); 3783 console.info('lastModifiedTime:' + data.lastModifiedTime); 3784 console.info('type:' + data.type); 3785 console.info('subFiles:' + data.subFiles + '}'); 3786 console.info('File_Get_013 => pass'); 3787 fileio.unlinkSync(ffpath); 3788 fileio.unlinkSync(fpath); 3789 fileio.rmdirSync(ddpath); 3790 fileio.rmdirSync(dpath); 3791 done(); 3792 }, 3793 fail: function (data, code) { 3794 console.info('File_Get_013 fail, code: ' + code + ', data: ' + data); 3795 expect(null).assertFail(); 3796 }, 3797 }); 3798 }); 3799 3800 /** 3801 * @tc.number SUB_STORAGE_File_Get_1400 3802 * @tc.name File_Get_014 3803 * @tc.desc Function of API, out of package, Virtual path, save the dir authority. 3804 */ 3805 it('File_Get_014', 0, async function (done) { 3806 file.get({ 3807 uri: 'internal://cache/../files/../../', 3808 success: function (data) { 3809 console.info('File_Get_014 => file list ：'); 3810 console.info('{uri:' ); 3811 console.info('length:' + data.length); 3812 console.info('lastModifiedTime:' + data.lastModifiedTime); 3813 console.info('type:' + data.type); 3814 console.info('subFiles:' + data.subFiles + '}'); 3815 console.info('File_Get_014 => pass'); 3816 done(); 3817 }, 3818 fail: function (data, code) { 3819 console.info('File_Get_014 fail, code: ' + code + ', data: ' + data); 3820 expect(null).assertFail(); 3821 }, 3822 complete: function () { 3823 console.info('get completed'); 3824 } 3825 }); 3826 }); 3827 /** 3828 * @tc.number SUB_STORAGE_Document_Choose_0100 3829 * @tc.name Document_Choose_001 3830 * @tc.desc Function of API, choose file.The test file is exist. 3831 */ 3832 it('File_Document_Choose_001', 0, async function (done) { 3833 try { 3834 let types = []; 3835 let code = await document.choose(types); 3836 let str = 'Error'; 3837 console.info("getFileUri===>" + code); 3838 expect(str).assertTrue(); 3839 done(); 3840 } 3841 catch (e) { 3842 console.info('File_Document_Choose_001 has failed for ' + e.message); 3843 expect(e.message == "error").assertTrue(); 3844 done(); 3845 } 3846 }); 3847 3848 /** 3849 * @tc.number SUB_STORAGE_Document_Choose_0200 3850 * @tc.name Document_Choose_002 3851 * @tc.desc Function of API, choose file.The test file is exist. 3852 */ 3853 it('File_Document_Choose_002', 0, async function (done) { 3854 try { 3855 let uri = ""; 3856 let code = await document.choose(function(err,uri){ 3857 3858 }); 3859 console.info("getFileUri===>" + code); 3860 expect(uri).assertTrue(); 3861 done(); 3862 } 3863 catch (e) { 3864 console.info('File_Document_Choose_002 has failed for ' + e.message); 3865 expect(e.message == "error").assertTrue(); 3866 done(); 3867 } 3868 }); 3869 3870 /** 3871 * @tc.number SUB_STORAGE_Document_Choose_0300 3872 * @tc.name Document_Choose_003 3873 * @tc.desc Function of API, choose file.The test file is exist. 3874 */ 3875 it('File_Document_Choose_003', 0, async function (done) { 3876 try { 3877 let types = []; 3878 let uri = ""; 3879 let code = await document.choose(types,function(err,uri){ 3880 3881 }); 3882 console.info("getFileUri===>" + code); 3883 expect().assertTrue(); 3884 done(); 3885 } 3886 catch (e) { 3887 console.info('File_Document_Choose_003 has failed for ' + e.message); 3888 expect(e.message == "error").assertTrue(); 3889 done(); 3890 } 3891 }); 3892 3893 /** 3894 * @tc.number SUB_STORAGE_Document_Show_0100 3895 * @tc.name Document_Show_001 3896 * @tc.desc Function of API, show file.The test file is exist. 3897 */ 3898 it('File_Document_Show_001', 0, async function (done) { 3899 try { 3900 let type = ""; 3901 let uri = ""; 3902 let code = await document.show(uri,type); 3903 console.info("getFileUri===>" + code); 3904 expect().assertTrue(); 3905 done(); 3906 } 3907 catch (e) { 3908 console.info('File_Document_Show_001 has failed for ' + e.message); 3909 expect(e.message == "error").assertTrue(); 3910 done(); 3911 } 3912 }); 3913 3914 /** 3915 * @tc.number SUB_STORAGE_Document_Show_0200 3916 * @tc.name Document_Show_002 3917 * @tc.desc Function of API, show file.The test file is exist. 3918 */ 3919 it('File_Document_Show_002', 0, async function (done) { 3920 try { 3921 let type = ""; 3922 let uri =""; 3923 let code = await document.show(uri,type,function(err){ 3924 3925 }); 3926 console.info("getFileUri===>" + code); 3927 expect().assertTrue(); 3928 done(); 3929 } 3930 catch (e) { 3931 console.info('File_Document_Show_002 has failed for ' + e.message); 3932 expect(e.message == "error").assertTrue(); 3933 done(); 3934 } 3935 }); 3936}); 3937} 3938