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 12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13* See the License for the specific language governing permissions and 14* limitations under the License. 15*/ 16import zlib from '@ohos.zlib' 17import fileio from '@ohos.fileio' 18import featureAbility from '@ohos.ability.featureAbility' 19import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect, Level } from '@ohos/hypium' 20 21let dir = ""; 22let infos = ""; 23let SRC_FILE_INVALID = 900001; 24let PARAM_ERROR = 401; 25 26export default function ActsZlibTest() { 27 describe('ActsZlibTest', function () { 28 beforeEach(async (done) => { 29 var context = featureAbility.getContext(); 30 context.getCacheDir((err, data) => { 31 console.info('ActsZlibTest successful. Data:' + JSON.stringify(data)); 32 dir = data; 33 var objectone = "com.example.amsZipfileUnzipfileST.MainAbility/com.example.amsZipfileUnzipfileST/"; 34 var objecttwo = "com.example.amsZipfileUnzipfileST.MainAbility/com.example.amsZipfileUnzipfileST/zipunzip"; 35 var objectthree = "com.example.amsZipfileUnzipfileST.MainAbility/ActsZlibTest/example.amsZipfileUnzipfileST"; 36 infos = dir + objectone + objecttwo + objectthree; 37 done(); 38 }) 39 }); 40 41 /* 42 * @tc.number: ACTS_ZipFile_0100 43 * @tc.name: zipFile 44 * @tc.desc: inFile is empty 45 */ 46 it('ACTS_ZipFile_0100', 0, async function (done) { 47 console.log("==================ACTS_ZipFile_0100 start=================="); 48 var path = ""; 49 var zipDest = dir + "/ACTS_ZipFile_0100.zip" 50 var options = {}; 51 options.level = zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION; 52 zlib.zipFile(path, zipDest, options).then((data) => { 53 console.log("ACTS_ZipFile_0100 data: " + data); 54 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 55 done(); 56 }).catch((err) => { 57 console.log("ACTS_ZipFile_0100 zipFile fail: " + err); 58 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 59 done(); 60 }) 61 console.log("==================ACTS_ZipFile_0100 end=================="); 62 }) 63 64 /* 65 * @tc.number: ACTS_ZipFile_0200 66 * @tc.name: zipFile 67 * @tc.desc: inFile doesn't exist 68 */ 69 it('ACTS_ZipFile_0200', 0, async function (done) { 70 console.log("==================ACTS_ZipFile_0200 start=================="); 71 var path = dir + "/ACTS_ZipFile_9999900.txt"; 72 var src = dir + "/ACTS_ZipFile_999991100.txt"; 73 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 74 fileio.write(fd, infos).then(function (number) { 75 console.info("ACTS_ZipFile_0200 write data to file successfully:" + number); 76 var options = {}; 77 options.level = zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION; 78 zlib.zipFile(src, dir, options).then((data) => { 79 console.log("ACTS_ZipFile_0200 data: " + data); 80 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 81 done(); 82 }).catch((err) => { 83 console.log("ACTS_ZipFile_0200 zipFile fail: " + err); 84 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 85 done(); 86 }) 87 }).catch(function (err) { 88 console.info("ACTS_ZipFile_0200 write data to file failed with error:" + err); 89 expect(err).assertFail(); 90 done(); 91 }); 92 console.log("==================ACTS_ZipFile_0200 end=================="); 93 }) 94 95 /* 96 * @tc.number: ACTS_ZipFile_0300 97 * @tc.name: zipFile 98 * @tc.desc: output file not specified 99 */ 100 it('ACTS_ZipFile_0300', 0, async function (done) { 101 console.log("==================ACTS_ZipFile_0300 start=================="); 102 var path = dir + "/ACTS_ZipFile_0300.txt"; 103 var zipDest = ""; 104 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 105 fileio.write(fd, infos).then(function (number) { 106 console.info("ACTS_ZipFile_0300 write data to file successfully:" + number); 107 var options = {}; 108 options.level = zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION; 109 zlib.zipFile(path, zipDest, options).then((data) => { 110 console.log("ACTS_ZipFile_0300 data: " + data); 111 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 112 done(); 113 }).catch((err) => { 114 console.log("ACTS_ZipFile_0300 zipFile fail: " + err); 115 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 116 done(); 117 }) 118 }).catch(function (err) { 119 console.info("ACTS_ZipFile_0300 write data to file failed with error:" + err); 120 expect(err).assertFail(); 121 done(); 122 }); 123 console.log("==================ACTS_ZipFile_0300 end=================="); 124 }) 125 126 /* 127 * @tc.number: ACTS_ZipFile_0400 128 * @tc.name: zipFile 129 * @tc.desc: The output file is a directory that does not exist 130 */ 131 it('ACTS_ZipFile_0400', 0, async function (done) { 132 console.log("==================ACTS_ZipFile_0400 start=================="); 133 var path = dir + "/ACTS_ZipFile_0400.txt"; 134 var zipDest = "/ACTS_ZipFile_0400.zip"; 135 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 136 fileio.write(fd, infos).then(function (number) { 137 console.info("ACTS_ZipFile_0400 write data to file successfully:" + number); 138 var options = {}; 139 options.level = zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION; 140 zlib.zipFile(path, zipDest, options).then((data) => { 141 console.log("ACTS_ZipFile_0400 data: " + data); 142 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 143 done(); 144 }).catch((err) => { 145 console.log("ACTS_ZipFile_0400 zipFile fail: " + err); 146 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 147 done(); 148 }) 149 }).catch(function (err) { 150 console.info("ACTS_ZipFile_0400 write data to file failed with error:" + err); 151 expect(err).assertFail(); 152 done(); 153 }); 154 console.log("==================ACTS_ZipFile_0400 end=================="); 155 }) 156 157 /* 158 * @tc.number: ACTS_ZipFile_2200 159 * @tc.name: zipFile 160 * @tc.desc: COMPRESS_LEVEL_NO_COMPRESSION, 161 */ 162 it('ACTS_ZipFile_2200', 0, async function (done) { 163 console.log("==================ACTS_ZipFile_2200 start=================="); 164 var path = dir + "/ACTS_ZipFile_2200.txt"; 165 var zipDest = dir + "/ACTS_ZipFile_2200.zip" 166 var unzipdir = dir + "/ACTS_ZipFile_2200"; 167 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2200.txt"; 168 var options = {}; 169 options.level = zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION; 170 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 171 fileio.write(fd, infos).then(function (number) { 172 console.info("ACTS_ZipFile_2200 write data to file secondlly successfully:" + number); 173 zlib.zipFile(path, zipDest, options).then((data) => { 174 var zipStat = fileio.statSync(zipDest); 175 var isFile = zipStat.isFile(); 176 expect(isFile).assertTrue(); 177 var srcSize = fileio.statSync(path).size; 178 var destSize = zipStat.size; 179 expect(srcSize > destSize).assertTrue(); 180 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 181 fileio.mkdir(unzipdir).then(function () { 182 console.info("ACTS_ZipFile_2200 mkdir successfully"); 183 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 184 var unzipStat = fileio.statSync(unzipresultfile); 185 var isFile = unzipStat.isFile(); 186 expect(isFile).assertTrue(); 187 var destSize = unzipStat.size; 188 var originSize = fileio.statSync(path).size; 189 var result = (originSize == destSize); 190 expect(result).assertTrue(); 191 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 192 console.error('ACTS_ZipFile_2200 unzipFile'); 193 done(); 194 }).catch((err) => { 195 console.log("ACTS_ZipFile_2200 err: " + err); 196 expect(err).assertFail(); 197 done(); 198 }) 199 }).catch(function (error) { 200 console.info("ACTS_ZipFile_2200 mkdir failed with error:" + error); 201 expect(error).assertFail(); 202 done(); 203 }); 204 }).catch((err) => { 205 console.log("zipFile fail: " + err); 206 expect(err).assertFail(); 207 done(); 208 }) 209 }).catch(function (err) { 210 console.info("ACTS_ZipFile_2200 write data to file failed with error:" + err); 211 expect(err).assertFail(); 212 done(); 213 }); 214 console.log("==================ACTS_ZipFile_2200 end=================="); 215 }); 216 217 /* 218 * @tc.number: ACTS_ZipFile_2300 219 * @tc.name: zipFile 220 * @tc.desc: COMPRESS_LEVEL_BEST_SPEED, 221 */ 222 it('ACTS_ZipFile_2300', 0, async function (done) { 223 console.log("==================ACTS_ZipFile_2300 start=================="); 224 var path = dir + "/ACTS_ZipFile_2300.txt"; 225 var zipDest = dir + "/ACTS_ZipFile_2300.zip" 226 var unzipdir = dir + "/ACTS_ZipFile_2300"; 227 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2300.txt"; 228 var options = {}; 229 options.level = zlib.CompressLevel.COMPRESS_LEVEL_BEST_SPEED; 230 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 231 fileio.write(fd, infos).then(function (number) { 232 console.info("ACTS_ZipFile_2300 write data to file successfully:" + number); 233 zlib.zipFile(path, zipDest, options).then((data) => { 234 var zipStat = fileio.statSync(zipDest); 235 var isFile = zipStat.isFile(); 236 expect(isFile).assertTrue(); 237 var srcSize = fileio.statSync(path).size; 238 var destSize = zipStat.size; 239 expect(srcSize > destSize).assertTrue(); 240 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 241 fileio.mkdir(unzipdir).then(function () { 242 console.info("ACTS_ZipFile_2300 mkdir successfully"); 243 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 244 var unzipStat = fileio.statSync(unzipresultfile); 245 var isFile = unzipStat.isFile(); 246 expect(isFile).assertTrue(); 247 var destSize = unzipStat.size; 248 var originSize = fileio.statSync(path).size; 249 var result = (originSize == destSize); 250 expect(result).assertTrue(); 251 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 252 console.error('ACTS_ZipFile_2300 unzipFile'); 253 done(); 254 }).catch((err) => { 255 console.log("ACTS_ZipFile_2300 err: " + err); 256 expect(err).assertFail(); 257 done(); 258 }) 259 }).catch(function (error) { 260 console.info("ACTS_ZipFile_2300 mkdir failed with error:" + error); 261 expect(error).assertFail(); 262 done(); 263 }); 264 }).catch((err) => { 265 console.log("zipFile fail: " + err); 266 expect(err).assertFail(); 267 done(); 268 }) 269 }).catch(function (err) { 270 console.info("ACTS_ZipFile_2300 write data to file failed with error:" + err); 271 expect(err).assertFail(); 272 done(); 273 }); 274 console.log("==================ACTS_ZipFile_2300 end=================="); 275 }) 276 277 /* 278 * @tc.number: ACTS_ZipFile_2400 279 * @tc.name: zipFile 280 * @tc.desc: COMPRESS_LEVEL_BEST_COMPRESSION, 281 */ 282 it('ACTS_ZipFile_2400', 0, async function (done) { 283 console.log("==================ACTS_ZipFile_2400 start=================="); 284 var path = dir + "/ACTS_ZipFile_2400.txt"; 285 var zipDest = dir + "/ACTS_ZipFile_2400.zip" 286 var unzipdir = dir + "/ACTS_ZipFile_2400"; 287 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2400.txt"; 288 var options = {}; 289 options.level = zlib.CompressLevel.COMPRESS_LEVEL_BEST_COMPRESSION; 290 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 291 fileio.write(fd, infos).then(function (number) { 292 console.info("ACTS_ZipFile_2400 write data to file successfully:" + number); 293 zlib.zipFile(path, zipDest, options).then((data) => { 294 var zipStat = fileio.statSync(zipDest); 295 var isFile = zipStat.isFile(); 296 expect(isFile).assertTrue(); 297 var srcSize = fileio.statSync(path).size; 298 var destSize = zipStat.size; 299 expect(srcSize > destSize).assertTrue(); 300 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 301 fileio.mkdir(unzipdir).then(function () { 302 console.info("ACTS_ZipFile_2400 mkdir successfully"); 303 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 304 var unzipStat = fileio.statSync(unzipresultfile); 305 var isFile = unzipStat.isFile(); 306 expect(isFile).assertTrue(); 307 var destSize = unzipStat.size; 308 var originSize = fileio.statSync(path).size; 309 var result = (originSize == destSize); 310 expect(result).assertTrue(); 311 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 312 console.error('ACTS_ZipFile_2400 unzipFile'); 313 done(); 314 }).catch((err) => { 315 console.log("ACTS_ZipFile_2400 err: " + err); 316 expect(err).assertFail(); 317 done(); 318 }) 319 }).catch(function (error) { 320 console.info("ACTS_ZipFile_2400 mkdir failed with error:" + error); 321 expect(error).assertFail(); 322 done(); 323 }); 324 }).catch((err) => { 325 console.log("zipFile fail: " + err); 326 expect(err).assertFail(); 327 done(); 328 }) 329 }).catch(function (err) { 330 console.info("ACTS_ZipFile_2400 write data to file failed with error:" + err); 331 expect(err).assertFail(); 332 done(); 333 }); 334 console.log("==================ACTS_ZipFile_2400 end=================="); 335 }); 336 337 /* 338 * @tc.number: ACTS_ZipFile_2500 339 * @tc.name: zipFile 340 * @tc.desc: COMPRESS_LEVEL_DEFAULT_COMPRESSION, 341 */ 342 it('ACTS_ZipFile_2500', 0, async function (done) { 343 console.log("==================ACTS_ZipFile_2500 start=================="); 344 var path = dir + "/ACTS_ZipFile_2500.txt"; 345 var zipDest = dir + "/ACTS_ZipFile_2500.zip" 346 var unzipdir = dir + "/ACTS_ZipFile_2500"; 347 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2500.txt"; 348 var options = {}; 349 options.level = zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION; 350 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 351 fileio.write(fd, infos).then(function (number) { 352 console.info("ACTS_ZipFile_2500 write data to file successfully:" + number); 353 zlib.zipFile(path, zipDest, options).then((data) => { 354 var zipStat = fileio.statSync(zipDest); 355 var isFile = zipStat.isFile(); 356 expect(isFile).assertTrue(); 357 var srcSize = fileio.statSync(path).size; 358 var destSize = zipStat.size; 359 expect(srcSize > destSize).assertTrue(); 360 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 361 fileio.mkdir(unzipdir).then(function () { 362 console.info("ACTS_ZipFile_2500 mkdir successfully"); 363 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 364 var unzipStat = fileio.statSync(unzipresultfile); 365 var isFile = unzipStat.isFile(); 366 expect(isFile).assertTrue(); 367 var destSize = unzipStat.size; 368 var originSize = fileio.statSync(path).size; 369 var result = (originSize == destSize); 370 expect(result).assertTrue(); 371 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 372 console.error('ACTS_ZipFile_2500 unzipFile'); 373 done(); 374 }).catch((err) => { 375 console.log("ACTS_ZipFile_2500 err: " + err); 376 expect(err).assertFail(); 377 done() 378 }) 379 }).catch(function (error) { 380 console.info("ACTS_ZipFile_2500 mkdir failed with error:" + error); 381 expect(error).assertFail(); 382 done(); 383 }); 384 }).catch((err) => { 385 console.log("zipFile fail: " + err); 386 expect(err).assertFail(); 387 done(); 388 }) 389 }).catch(function (err) { 390 console.info("ACTS_ZipFile_2500 write data to file failed with error:" + err); 391 expect(err).assertFail(); 392 done(); 393 }); 394 console.log("==================ACTS_ZipFile_2500 end=================="); 395 }); 396 397 /* 398 * @tc.number: ACTS_ZipFile_2600 399 * @tc.name: zipFile 400 * @tc.desc: MEM_LEVEL_MIN_MEMLEVEL,, 401 */ 402 it('ACTS_ZipFile_2600', 0, async function (done) { 403 console.log("==================ACTS_ZipFile_2600 start=================="); 404 var path = dir + "/ACTS_ZipFile_2600.txt"; 405 var zipDest = dir + "/ACTS_ZipFile_2600.zip" 406 var unzipdir = dir + "/ACTS_ZipFile_2600"; 407 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2600.txt"; 408 var options = {}; 409 options.memLevel = zlib.MemLevel.MEM_LEVEL_MIN; 410 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 411 fileio.write(fd, infos).then(function (number) { 412 console.info("ACTS_ZipFile_2600 write data to file successfully:" + number); 413 zlib.zipFile(path, zipDest, options).then((data) => { 414 var zipStat = fileio.statSync(zipDest); 415 var isFile = zipStat.isFile(); 416 expect(isFile).assertTrue(); 417 var srcSize = fileio.statSync(path).size; 418 var destSize = zipStat.size; 419 expect(srcSize > destSize).assertTrue(); 420 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 421 fileio.mkdir(unzipdir).then(function () { 422 console.info("ACTS_ZipFile_2600 mkdir successfully"); 423 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 424 var unzipStat = fileio.statSync(unzipresultfile); 425 var isFile = unzipStat.isFile(); 426 expect(isFile).assertTrue(); 427 var destSize = unzipStat.size; 428 var originSize = fileio.statSync(path).size; 429 var result = (originSize == destSize); 430 expect(result).assertTrue(); 431 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 432 console.error('ACTS_ZipFile_2600 unzipFile'); 433 done(); 434 }).catch((err) => { 435 console.log("ACTS_ZipFile_2600 err: " + err); 436 expect(err).assertFail(); 437 done(); 438 }) 439 }).catch(function (error) { 440 console.info("ACTS_ZipFile_2600 mkdir failed with error:" + error); 441 expect(error).assertFail(); 442 done(); 443 }); 444 }).catch((err) => { 445 console.log("zipFile fail: " + err); 446 expect(err).assertFail(); 447 done(); 448 }) 449 }).catch(function (err) { 450 console.info("ACTS_ZipFile_2600 write data to file failed with error:" + err); 451 expect(err).assertFail(); 452 done(); 453 }); 454 console.log("==================ACTS_ZipFile_2600 end=================="); 455 }); 456 457 /* 458 * @tc.number: ACTS_ZipFile_2700 459 * @tc.name: zipFile 460 * @tc.desc: MEM_LEVEL_MAX_MEMLEVEL,, 461 */ 462 it('ACTS_ZipFile_2700', 0, async function (done) { 463 console.log("==================ACTS_ZipFile_2700 start=================="); 464 var path = dir + "/ACTS_ZipFile_2700.txt"; 465 var zipDest = dir + "/ACTS_ZipFile_2700.zip" 466 var unzipdir = dir + "/ACTS_ZipFile_2700"; 467 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2700.txt"; 468 var options = {}; 469 options.memLevel = zlib.MemLevel.MEM_LEVEL_MAX; 470 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 471 fileio.write(fd, infos).then(function (number) { 472 console.info("ACTS_ZipFile_2700 write data to file successfully:" + number); 473 zlib.zipFile(path, zipDest, options).then((data) => { 474 var zipStat = fileio.statSync(zipDest); 475 var isFile = zipStat.isFile(); 476 expect(isFile).assertTrue(); 477 var srcSize = fileio.statSync(path).size; 478 var destSize = zipStat.size; 479 expect(srcSize > destSize).assertTrue(); 480 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 481 fileio.mkdir(unzipdir).then(function () { 482 console.info("ACTS_ZipFile_2700 mkdir successfully"); 483 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 484 var unzipStat = fileio.statSync(unzipresultfile); 485 var isFile = unzipStat.isFile(); 486 expect(isFile).assertTrue(); 487 var destSize = unzipStat.size; 488 var originSize = fileio.statSync(path).size; 489 var result = (originSize == destSize); 490 expect(result).assertTrue(); 491 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 492 console.error('ACTS_ZipFile_2700 unzipFile'); 493 done(); 494 }).catch((err) => { 495 console.log("ACTS_ZipFile_2700 err: " + err); 496 expect(err).assertFail(); 497 done(); 498 }) 499 }).catch(function (error) { 500 console.info("ACTS_ZipFile_2700 mkdir failed with error:" + error); 501 expect(error).assertFail(); 502 done(); 503 }); 504 }).catch((err) => { 505 console.log("zipFile fail: " + err); 506 expect(err).assertFail(); 507 done(); 508 }) 509 }).catch(function (err) { 510 console.info("ACTS_ZipFile_2700 write data to file failed with error:" + err); 511 expect(err).assertFail(); 512 done(); 513 }); 514 console.log("==================ACTS_ZipFile_2700 end=================="); 515 }); 516 517 /* 518 * @tc.number: ACTS_ZipFile_2800 519 * @tc.name: zipFile 520 * @tc.desc: MEM_LEVEL_DEFAULT_MEMLEVEL,, 521 */ 522 it('ACTS_ZipFile_2800', 0, async function (done) { 523 console.log("==================ACTS_ZipFile_2800 start=================="); 524 var path = dir + "/ACTS_ZipFile_2800.txt"; 525 var zipDest = dir + "/ACTS_ZipFile_2800.zip" 526 var unzipdir = dir + "/ACTS_ZipFile_2800"; 527 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2800.txt"; 528 var options = {}; 529 options.memLevel = zlib.MemLevel.MEM_LEVEL_DEFAULT; 530 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 531 fileio.write(fd, infos).then(function (number) { 532 console.info("ACTS_ZipFile_2800 write data to file successfully:" + number); 533 zlib.zipFile(path, zipDest, options).then((data) => { 534 var zipStat = fileio.statSync(zipDest); 535 var isFile = zipStat.isFile(); 536 expect(isFile).assertTrue(); 537 var srcSize = fileio.statSync(path).size; 538 var destSize = zipStat.size; 539 expect(srcSize > destSize).assertTrue(); 540 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 541 fileio.mkdir(unzipdir).then(function () { 542 console.info("ACTS_ZipFile_2800 mkdir successfully"); 543 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 544 var unzipStat = fileio.statSync(unzipresultfile); 545 var isFile = unzipStat.isFile(); 546 expect(isFile).assertTrue(); 547 var destSize = unzipStat.size; 548 var originSize = fileio.statSync(path).size; 549 var result = (originSize == destSize); 550 expect(result).assertTrue(); 551 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 552 console.error('ACTS_ZipFile_2800 unzipFile'); 553 done(); 554 }).catch((err) => { 555 console.log("ACTS_ZipFile_2800 err: " + err); 556 expect(err).assertFail(); 557 done(); 558 }) 559 }).catch(function (error) { 560 console.info("ACTS_ZipFile_2800 mkdir failed with error:" + error); 561 expect(error).assertFail(); 562 done(); 563 }); 564 }).catch((err) => { 565 console.log("zipFile fail: " + err); 566 expect(err).assertFail(); 567 done(); 568 }) 569 }).catch(function (err) { 570 console.info("ACTS_ZipFile_2800 write data to file failed with error:" + err); 571 expect(err).assertFail(); 572 done(); 573 }); 574 console.log("==================ACTS_ZipFile_2800 end=================="); 575 }); 576 577 /* 578 * @tc.number: ACTS_ZipFile_2900 579 * @tc.name: zipFile 580 * @tc.desc: COMPRESS_STRATEGY_DEFAULT_STRATEGY,, 581 */ 582 it('ACTS_ZipFile_2900', 0, async function (done) { 583 console.log("==================ACTS_ZipFile_2900 start=================="); 584 var path = dir + "/ACTS_ZipFile_2900.txt"; 585 var zipDest = dir + "/ACTS_ZipFile_2900.zip" 586 var unzipdir = dir + "/ACTS_ZipFile_2900"; 587 var unzipresultfile = unzipdir + "/ACTS_ZipFile_2900.txt"; 588 var options = {}; 589 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_DEFAULT_STRATEGY; 590 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 591 fileio.write(fd, infos).then(function (number) { 592 console.info("ACTS_ZipFile_2900 write data to file successfully:" + number); 593 zlib.zipFile(path, zipDest, options).then((data) => { 594 var zipStat = fileio.statSync(zipDest); 595 var isFile = zipStat.isFile(); 596 expect(isFile).assertTrue(); 597 var srcSize = fileio.statSync(path).size; 598 var destSize = zipStat.size; 599 expect(srcSize > destSize).assertTrue(); 600 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 601 fileio.mkdir(unzipdir).then(function () { 602 console.info("ACTS_ZipFile_2900 mkdir successfully"); 603 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 604 var unzipStat = fileio.statSync(unzipresultfile); 605 var isFile = unzipStat.isFile(); 606 expect(isFile).assertTrue(); 607 var destSize = unzipStat.size; 608 var originSize = fileio.statSync(path).size; 609 var result = (originSize == destSize); 610 expect(result).assertTrue(); 611 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 612 console.error('ACTS_ZipFile_2900 unzipFile'); 613 done(); 614 }).catch((err) => { 615 console.log("ACTS_ZipFile_2900 err: " + err); 616 expect(err).assertFail(); 617 done(); 618 }) 619 }).catch(function (error) { 620 console.info("ACTS_ZipFile_2900 mkdir failed with error:" + error); 621 expect(error).assertFail(); 622 done(); 623 }); 624 }).catch((err) => { 625 console.log("zipFile fail: " + err); 626 expect(err).assertFail(); 627 done(); 628 }) 629 }).catch(function (err) { 630 console.info("ACTS_ZipFile_2900 write data to file failed with error:" + err); 631 expect(err).assertFail(); 632 done(); 633 }); 634 console.log("==================ACTS_ZipFile_2900 end=================="); 635 }); 636 637 /* 638 * @tc.number: ACTS_ZipFile_3000 639 * @tc.name: zipFile 640 * @tc.desc: COMPRESS_STRATEGY_FILTERED,, 641 */ 642 it('ACTS_ZipFile_3000', 0, async function (done) { 643 console.log("==================ACTS_ZipFile_3000 start=================="); 644 var path = dir + "/ACTS_ZipFile_3000.txt"; 645 var zipDest = dir + "/ACTS_ZipFile_3000.zip" 646 var unzipdir = dir + "/ACTS_ZipFile_3000"; 647 var unzipresultfile = unzipdir + "/ACTS_ZipFile_3000.txt"; 648 var options = {}; 649 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FILTERED; 650 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 651 fileio.write(fd, infos).then(function (number) { 652 console.info("ACTS_ZipFile_3000 write data to file successfully:" + number); 653 zlib.zipFile(path, zipDest, options).then((data) => { 654 var zipStat = fileio.statSync(zipDest); 655 var isFile = zipStat.isFile(); 656 expect(isFile).assertTrue(); 657 var srcSize = fileio.statSync(path).size; 658 var destSize = zipStat.size; 659 expect(srcSize > destSize).assertTrue(); 660 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 661 fileio.mkdir(unzipdir).then(function () { 662 console.info("ACTS_ZipFile_3000 mkdir successfully"); 663 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 664 var unzipStat = fileio.statSync(unzipresultfile); 665 var isFile = unzipStat.isFile(); 666 expect(isFile).assertTrue(); 667 var destSize = unzipStat.size; 668 var originSize = fileio.statSync(path).size; 669 var result = (originSize == destSize); 670 expect(result).assertTrue(); 671 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 672 console.error('ACTS_ZipFile_3000 unzipFile'); 673 done(); 674 }).catch((err) => { 675 console.log("ACTS_ZipFile_3000 err: " + err); 676 expect(err).assertFail(); 677 done(); 678 }) 679 }).catch(function (error) { 680 console.info("ACTS_ZipFile_3000 mkdir failed with error:" + error); 681 expect(error).assertFail(); 682 done(); 683 }); 684 }).catch((err) => { 685 console.log("zipFile fail: " + err); 686 expect(err).assertFail(); 687 done(); 688 }) 689 }).catch(function (err) { 690 console.info("ACTS_ZipFile_3000 write data to file failed with error:" + err); 691 expect(err).assertFail(); 692 done(); 693 }); 694 console.log("==================ACTS_ZipFile_3000 end=================="); 695 }); 696 697 /* 698 * @tc.number: ACTS_ZipFile_3100 699 * @tc.name: zipFile 700 * @tc.desc: COMPRESS_STRATEGY_HUFFMAN_ONLY,, 701 */ 702 it('ACTS_ZipFile_3100', 0, async function (done) { 703 console.log("==================ACTS_ZipFile_3100 start=================="); 704 var path = dir + "/ACTS_ZipFile_3100.txt"; 705 var zipDest = dir + "/ACTS_ZipFile_3100.zip" 706 var unzipdir = dir + "/ACTS_ZipFile_3100"; 707 var unzipresultfile = unzipdir + "/ACTS_ZipFile_3100.txt"; 708 var options = {}; 709 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_HUFFMAN_ONLY; 710 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 711 fileio.write(fd, infos).then(function (number) { 712 console.info("ACTS_ZipFile_3100 write data to file successfully:" + number); 713 zlib.zipFile(path, zipDest, options).then((data) => { 714 var zipStat = fileio.statSync(zipDest); 715 var isFile = zipStat.isFile(); 716 expect(isFile).assertTrue(); 717 var srcSize = fileio.statSync(path).size; 718 var destSize = zipStat.size; 719 expect(srcSize > destSize).assertTrue(); 720 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 721 fileio.mkdir(unzipdir).then(function () { 722 console.info("ACTS_ZipFile_3100 mkdir successfully"); 723 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 724 var unzipStat = fileio.statSync(unzipresultfile); 725 var isFile = unzipStat.isFile(); 726 expect(isFile).assertTrue(); 727 var destSize = unzipStat.size; 728 var originSize = fileio.statSync(path).size; 729 var result = (originSize == destSize); 730 expect(result).assertTrue(); 731 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 732 console.error('ACTS_ZipFile_3100 unzipFile'); 733 done(); 734 }).catch((err) => { 735 console.log("ACTS_ZipFile_3100 err: " + err); 736 expect(err).assertFail(); 737 done(); 738 }) 739 }).catch(function (error) { 740 console.info("ACTS_ZipFile_3100 mkdir failed with error:" + error); 741 expect(error).assertFail(); 742 done(); 743 }); 744 }).catch((err) => { 745 console.log("zipFile fail: " + err); 746 expect(err).assertFail(); 747 done(); 748 }) 749 }).catch(function (err) { 750 console.info("ACTS_ZipFile_3100 write data to file failed with error:" + err); 751 expect(err).assertFail(); 752 done(); 753 }); 754 console.log("==================ACTS_ZipFile_3100 end=================="); 755 }); 756 757 /* 758 * @tc.number: ACTS_ZipFile_3200 759 * @tc.name: zipFile 760 * @tc.desc: COMPRESS_STRATEGY_RLE,, 761 */ 762 it('ACTS_ZipFile_3200', 0, async function (done) { 763 console.log("==================ACTS_ZipFile_3200 start=================="); 764 var path = dir + "/ACTS_ZipFile_3200.txt"; 765 var zipDest = dir + "/ACTS_ZipFile_3200.zip"; 766 var unzipdir = dir + "/ACTS_ZipFile_3200"; 767 var unzipresultfile = unzipdir + "/ACTS_ZipFile_3200.txt"; 768 var options = {}; 769 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_RLE; 770 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 771 fileio.write(fd, infos).then(function (number) { 772 console.info("ACTS_ZipFile_3200 write data to file successfully:" + number); 773 zlib.zipFile(path, zipDest, options).then((data) => { 774 var zipStat = fileio.statSync(zipDest); 775 var isFile = zipStat.isFile(); 776 expect(isFile).assertTrue(); 777 var srcSize = fileio.statSync(path).size; 778 var destSize = zipStat.size; 779 expect(srcSize > destSize).assertTrue(); 780 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 781 fileio.mkdir(unzipdir).then(function () { 782 console.info("ACTS_ZipFile_3200 mkdir successfully"); 783 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 784 var unzipStat = fileio.statSync(unzipresultfile); 785 var isFile = unzipStat.isFile(); 786 expect(isFile).assertTrue(); 787 var destSize = unzipStat.size; 788 var originSize = fileio.statSync(path).size; 789 var result = (originSize == destSize); 790 expect(result).assertTrue(); 791 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 792 console.error('ACTS_ZipFile_3200 unzipFile'); 793 done(); 794 }).catch((err) => { 795 console.log("ACTS_ZipFile_3200 err: " + err); 796 done(); 797 expect(err).assertFail(); 798 done(); 799 }) 800 }).catch(function (error) { 801 console.info("ACTS_ZipFile_3200 mkdir failed with error:" + error); 802 expect(error).assertFail(); 803 done(); 804 }); 805 }).catch((err) => { 806 console.log("zipFile fail: " + err); 807 expect(err).assertFail(); 808 done(); 809 }) 810 }).catch(function (err) { 811 console.info("ACTS_ZipFile_3200 write data to file failed with error:" + err); 812 expect(err).assertFail(); 813 done(); 814 }); 815 console.log("==================ACTS_ZipFile_3200 end=================="); 816 }); 817 818 /* 819 * @tc.number: ACTS_ZipFile_3300 820 * @tc.name: zipFile 821 * @tc.desc: COMPRESS_STRATEGY_FIXED,, 822 */ 823 it('ACTS_ZipFile_3300', 0, async function (done) { 824 console.log("==================ACTS_ZipFile_3300 start=================="); 825 var path = dir + "/ACTS_ZipFile_3300.txt"; 826 var zipDest = dir + "/ACTS_ZipFile_3300.zip" 827 var unzipdir = dir + "/ACTS_ZipFile_3300"; 828 var unzipresultfile = unzipdir + "/ACTS_ZipFile_3300.txt"; 829 var options = {}; 830 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED; 831 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 832 fileio.write(fd, infos).then(function (number) { 833 console.info("ACTS_ZipFile_3300 write data to file successfully:" + number); 834 zlib.zipFile(path, zipDest, options).then((data) => { 835 var zipStat = fileio.statSync(zipDest); 836 var isFile = zipStat.isFile(); 837 expect(isFile).assertTrue(); 838 var srcSize = fileio.statSync(path).size; 839 var destSize = zipStat.size; 840 expect(srcSize > destSize).assertTrue(); 841 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 842 fileio.mkdir(unzipdir).then(function () { 843 console.info("ACTS_ZipFile_3300 mkdir successfully"); 844 zlib.unzipFile(zipDest, unzipdir, options).then((data) => { 845 var unzipStat = fileio.statSync(unzipresultfile); 846 var isFile = unzipStat.isFile(); 847 expect(isFile).assertTrue(); 848 var destSize = unzipStat.size; 849 var originSize = fileio.statSync(path).size; 850 var result = (originSize == destSize); 851 expect(result).assertTrue(); 852 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 853 console.error('ACTS_ZipFile_3300 unzipFile'); 854 done(); 855 }).catch((err) => { 856 console.log("ACTS_ZipFile_3300 err: " + err); 857 expect(err).assertFail(); 858 done(); 859 }) 860 }).catch(function (error) { 861 console.info("ACTS_ZipFile_3300 mkdir failed with error:" + error); 862 expect(error).assertFail(); 863 done(); 864 }); 865 }).catch((err) => { 866 console.log("zipFile fail: " + err); 867 expect(err).assertFail(); 868 done(); 869 }) 870 }).catch(function (err) { 871 console.info("ACTS_ZipFile_3300 write data to file failed with error:" + err); 872 expect(err).assertFail(); 873 done(); 874 }); 875 console.log("==================ACTS_ZipFile_3300 end=================="); 876 }); 877 878 /* 879 * @tc.number: ACTS_ZipFile_3500 880 * @tc.name: zipFile 881 * @tc.desc: INPUT_FILE_NOT_EXIST,, 882 */ 883 it('ACTS_ZipFile_3500', 0, async function (done) { 884 console.log("==================ACTS_ZipFile_3500 start=================="); 885 var path = dir + "/ACTS_ZipFile_3500.txt"; 886 var src = dir + "/ACTS_ZipFile_9900.txt"; 887 var unzipdir = dir + "/ACTS_ZipFile_3500"; 888 var options = {}; 889 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FILTERED; 890 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 891 fileio.write(fd, infos).then(function (number) { 892 console.info("ACTS_ZipFile_3500 write successfully:" + number); 893 zlib.zipFile(src, dir, options).then((data) => { 894 console.log("ACTS_ZipFile_3500 data: " + data); 895 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 896 done(); 897 }).catch((err) => { 898 console.log("ACTS_ZipFile_3500 err: " + err); 899 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 900 done(); 901 }); 902 }).catch(function (err) { 903 console.info("ACTS_ZipFile_3500 write data to file failed with error:" + err); 904 expect(err).assertFail(); 905 done(); 906 }); 907 console.log("==================ACTS_ZipFile_3500 end =================="); 908 }) 909 910 /* 911 * @tc.number: ACTS_ZipFile_3600 912 * @tc.name: zipFile 913 * @tc.desc: INPUT_FILE_NULL,, 914 */ 915 it('ACTS_ZipFile_3600', 0, async function (done) { 916 console.log("==================ACTS_ZipFile_3600 start=================="); 917 var path = dir + "/ACTS_ZipFile_3600.txt"; 918 var zipDest = ""; 919 var options = {}; 920 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FILTERED; 921 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 922 fileio.write(fd, infos).then(function (number) { 923 console.info("ACTS_ZipFile_3600 write data to file successfully:" + number); 924 zlib.zipFile(path, zipDest, options).then((data) => { 925 console.log("ACTS_ZipFile_3600 data: " + data); 926 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 927 done(); 928 }).catch((err) => { 929 console.log("ACTS_ZipFile_3600 err: " + err); 930 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 931 done(); 932 }); 933 }).catch(function (err) { 934 console.info("ACTS_ZipFile_3600 write data to file failed with error:" + err); 935 expect(err).assertFail(); 936 done(); 937 }); 938 console.log("==================ACTS_ZipFile_3600 end ==================") 939 }) 940 941 /* 942 * @tc.number: ACTS_ZipFile_4500 943 * @tc.name: zipFile 944 * @tc.desc: COMPRESS_STRATEGY_FILTERED_CALLBACK,, 945 */ 946 it('ACTS_ZipFile_4500', 0, async function (done) { 947 console.log("==================ACTS_ZipFile_4500 start=================="); 948 var path = dir + "/ACTS_ZipFile_4500.txt"; 949 var zipDest = dir + "/ACTS_ZipFile_4500.zip" 950 var unzipDest = dir + "/ACTS_ZipFile_9900.zip" 951 var unzipdir = dir + "/ACTS_ZipFile_4500"; 952 var zipdir = dir + "/ACTS_ZipFile_9900"; 953 var options = {}; 954 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FILTERED; 955 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 956 fileio.write(fd, infos).then(function (number) { 957 console.info("ACTS_ZipFile_4500 write data to file successfully:" + number); 958 zlib.zipFile(path, zipDest, options).then((data) => { 959 var zipStat = fileio.statSync(zipDest); 960 var isFile = zipStat.isFile(); 961 expect(isFile).assertTrue(); 962 var srcSize = fileio.statSync(path).size; 963 var destSize = zipStat.size; 964 expect(srcSize > destSize).assertTrue(); 965 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 966 fileio.mkdir(unzipdir).then(function () { 967 console.info("ACTS_ZipFile_4500 mkdir successfully"); 968 zlib.unzipFile(unzipDest, zipdir, options).then((data) => { 969 console.log("ACTS_ZipFile_4500 data: " + data); 970 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 971 done(); 972 }).catch((err) => { 973 console.log("ACTS_ZipFile_4500 err: " + err); 974 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 975 done(); 976 }) 977 }).catch(function (error) { 978 console.info("ACTS_ZipFile_4500 mkdir failed with error:" + error); 979 expect(error).assertFail(); 980 done(); 981 }); 982 }).catch((err) => { 983 console.log("ACTS_ZipFile_4500 zipFile fail: " + err); 984 expect(err).assertEqual(zlib.ErrorCode.ERROR_CODE_ERRNO); 985 done(); 986 }) 987 }).catch(function (err) { 988 console.info("ACTS_ZipFile_4500 write data to file failed with error:" + err); 989 expect(err).assertFail(); 990 done(); 991 }); 992 console.log("==================ACTS_ZipFile_4500 end=================="); 993 }) 994 995 /* 996 * @tc.number: ACTS_ZipFile_4900 997 * @tc.name: zipFile 998 * @tc.desc: COMPRESS_STRATEGY_FILTERED_PROMISE, 999 */ 1000 it('ACTS_ZipFile_4900', 0, async function (done) { 1001 console.log("==================ACTS_ZipFile_4900 start=================="); 1002 var path = dir + "/ACTS_ZipFile_4900.txt"; 1003 var zipDest = dir + "/ACTS_ZipFile_4900.zip" 1004 var unzipDest = dir + "/ACTS_ZipFile_4900.zip" 1005 var unzipdir = dir + "/ACTS_ZipFile_4900"; 1006 var zipdir = dir + "/ACTS_ZipFile_4900"; 1007 var options = {}; 1008 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FILTERED; 1009 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1010 fileio.write(fd, infos).then(function (number) { 1011 console.info("ACTS_ZipFile_4900 write data to file successfully:" + number); 1012 zlib.zipFile(path, zipDest, options).then(data => { 1013 var zipStat = fileio.statSync(zipDest); 1014 var isFile = zipStat.isFile(); 1015 expect(isFile).assertTrue(); 1016 var srcSize = fileio.statSync(path).size; 1017 var destSize = zipStat.size; 1018 expect(srcSize > destSize).assertTrue(); 1019 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 1020 fileio.mkdir(unzipdir).then(function () { 1021 console.info("ACTS_ZipFile_4900 mkdir successfully"); 1022 zlib.unzipFile(unzipDest, zipdir, options).then(data => { 1023 console.log("ACTS_ZipFile_4900 data: " + data); 1024 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 1025 done(); 1026 }).catch(err => { 1027 console.log("ACTS_ZipFile_4900 err: " + err); 1028 expect(err).assertFail(); 1029 done(); 1030 }) 1031 }).catch(function (error) { 1032 console.info("ACTS_ZipFile_4900 mkdir failed with error:" + error); 1033 expect(error).assertFail(); 1034 done(); 1035 }); 1036 }).catch(err => { 1037 console.log("ACTS_ZipFile_4900 zipFile fail: " + err); 1038 expect(err).assertFail(); 1039 done(); 1040 }) 1041 }).catch(function (err) { 1042 console.info("ACTS_ZipFile_4900 write data to file failed with error:" + err); 1043 expect(err).assertFail(); 1044 done(); 1045 }); 1046 console.log("==================ACTS_ZipFile_4900 end=================="); 1047 }) 1048 1049 /* 1050 * @tc.number: ACTS_ZipFile_5000 1051 * @tc.name: zipFile 1052 * @tc.desc: COMPRESS_STRATEGY_FIXED, 1053 */ 1054 it('ACTS_ZipFile_5000', 0, async function (done) { 1055 console.log("==================ACTS_ZipFile_5000 start=================="); 1056 var path = dir + "/ACTS_ZipFile_5000.txt"; 1057 var zipDest = dir + "/ACTS_ZipFile_5000.zip" 1058 var unzipdir = dir + "/ACTS_ZipFile_5000"; 1059 var options = {}; 1060 options.strategy = zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED; 1061 var fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1062 fileio.write(fd, infos).then(function (number) { 1063 console.info("ACTS_ZipFile_5000 write data to file successfully:" + number); 1064 zlib.zipFile(path, zipDest, options).then(data => { 1065 var zipStat = fileio.statSync(zipDest); 1066 var isFile = zipStat.isFile(); 1067 expect(isFile).assertTrue(); 1068 var srcSize = fileio.statSync(path).size; 1069 var destSize = zipStat.size; 1070 expect(srcSize > destSize).assertTrue(); 1071 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 1072 fileio.mkdir(unzipdir).then(function () { 1073 console.info("ACTS_ZipFile_5000 mkdir successfully"); 1074 zlib.unzipFile(zipDest, unzipdir, options).then(data => { 1075 console.log("ACTS_ZipFile_5000 data: " + data); 1076 expect(data).assertEqual(zlib.ErrorCode.ERROR_CODE_OK); 1077 done(); 1078 }).catch(err => { 1079 console.log("unzipFile fail: " + err); 1080 expect(err).assertFail(); 1081 done(); 1082 }) 1083 }).catch(function (error) { 1084 console.info("ACTS_ZipFile_5000 mkdir failed with error:" + error); 1085 expect(error).assertFail(); 1086 done(); 1087 }); 1088 }).catch(err => { 1089 console.log("zipFile fail: " + err); 1090 expect(err).assertFail(); 1091 done(); 1092 }) 1093 }).catch(function (err) { 1094 console.info("ACTS_ZipFile_5000 write data to file failed with error:" + err); 1095 expect(err).assertFail(); 1096 done(); 1097 }); 1098 console.log("==================ACTS_ZipFile_5000 end=================="); 1099 }) 1100 1101 /* 1102 * @tc.number: SUB_BMS_TOOL_ZLIB_0077 1103 * @tc.name: compressFileTest 1104 * @tc.desc: test compressFile when inFile and out file is valid 1105 */ 1106 it('compressFileTest', Level.LEVEL2, async function (done) { 1107 console.log("==================compressFileTest start=================="); 1108 let path1 = dir + "/compressFileTest1.txt"; 1109 let zipDest1 = dir + "/compressFileTest1.zip"; 1110 let path2 = dir + "/compressFileTest2.txt"; 1111 let zipDest2 = dir + "/compressFileTest2.zip"; 1112 let fd = fileio.openSync(path1, 0o100 | 0o2, 0o666); 1113 await fileio.write(fd, infos).then(function (number) { 1114 console.info("compressFileTest write data to file successfully :" + number); 1115 }).catch(function (err) { 1116 console.info("compressFileTest write data to file failed with error:" + err); 1117 expect(err).assertFail(); 1118 }); 1119 console.info("compressFileTest start compressFile"); 1120 await zlib.compressFile(path1, zipDest1, { 1121 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1122 }).then((data) => { 1123 console.info("compressFileTest data: " + JSON.stringify(data)); 1124 let zipStat = fileio.statSync(zipDest1); 1125 let isFile = zipStat.isFile(); 1126 expect(isFile).assertTrue(); 1127 let srcSize = fileio.statSync(path1).size; 1128 let destSize = zipStat.size; 1129 expect(srcSize > destSize).assertTrue(); 1130 expect(data).assertEqual(null); 1131 }).catch((err) => { 1132 console.info("compressFileTest data: " + JSON.stringify(err)); 1133 expect(err).assertFail(); 1134 }) 1135 let fd2 = fileio.openSync(path2, 0o100 | 0o2, 0o666); 1136 await fileio.write(fd2, infos).then(function (number) { 1137 console.info("compressFileTest write data to file successfully :" + number); 1138 }).catch(function (err) { 1139 console.info("compressFileTest write data to file failed with error:" + err); 1140 expect(err).assertFail(); 1141 }); 1142 zlib.compressFile(path2, zipDest2, { 1143 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1144 }, (err, data) => { 1145 console.info("compressFileTest data2: " + JSON.stringify(data)); 1146 console.info("compressFileTest err2: " + JSON.stringify(err)); 1147 let zipStat = fileio.statSync(zipDest2); 1148 let isFile = zipStat.isFile(); 1149 expect(isFile).assertTrue(); 1150 let srcSize = fileio.statSync(path2).size; 1151 let destSize = zipStat.size; 1152 expect(srcSize > destSize).assertTrue(); 1153 expect(data).assertEqual(undefined); 1154 expect(err).assertEqual(null); 1155 done(); 1156 }) 1157 }) 1158 1159 /* 1160 * @tc.number: SUB_BMS_TOOL_ZLIB_0078 1161 * @tc.name: compressFileInFileNotExist 1162 * @tc.desc: test compressFile when inFile is not exist 1163 */ 1164 it('compressFileInFileNotExist', Level.LEVEL3, async function (done) { 1165 console.log("==================compressFileInFileNotExist start=================="); 1166 let path = "nonexist.txt"; 1167 let zipDest = dir + "/compressFileInFileNotExist.zip"; 1168 await zlib.compressFile(path, zipDest, { 1169 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1170 }).then((data) => { 1171 console.log("compressFileInFileNotExist invalid src file success!"); 1172 expect(data).assertFail(); 1173 done(); 1174 }).catch((err) => { 1175 console.log("compressFileInFileNotExist zipFile fail: " + JSON.stringify(err)); 1176 expect(err.code).assertEqual(SRC_FILE_INVALID); 1177 done(); 1178 }) 1179 zlib.compressFile(path, zipDest, { 1180 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1181 }, (err, data) => { 1182 expect(err.code).assertEqual(SRC_FILE_INVALID); 1183 expect(data).assertEqual(undefined); 1184 done(); 1185 }) 1186 console.log("==================compressFileInFileNotExist end=================="); 1187 }) 1188 1189 /* 1190 * @tc.number: SUB_BMS_TOOL_ZLIB_0079 1191 * @tc.name: compressFileInFileNull 1192 * @tc.desc: test compressFile when inFile is null 1193 */ 1194 it('compressFileInFileNull', Level.LEVEL3, async function (done) { 1195 console.log("==================compressFileInFileNull start=================="); 1196 let zipDest = dir + "/compressFileInFileNull.zip"; 1197 try { 1198 await zlib.compressFile(null, zipDest, { 1199 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1200 }).then((data) => { 1201 console.log("compressFileInFileNull invalid src file success!"); 1202 expect().assertFail(); 1203 }).catch((err) => { 1204 console.log("compressFileInFileNull zipFile fail: " + JSON.stringify(err)); 1205 expect().assertFail(); 1206 }) 1207 } catch (err) { 1208 expect(err.code).assertEqual(PARAM_ERROR); 1209 } 1210 try { 1211 zlib.compressFile(null, zipDest, { 1212 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1213 }, (err, data) => { 1214 console.log("compressFile result"); 1215 expect().assertFail(); 1216 done(); 1217 }) 1218 } catch (err) { 1219 expect(err.code).assertEqual(PARAM_ERROR); 1220 done(); 1221 } 1222 console.log("==================compressFileInFileNull end=================="); 1223 }) 1224 1225 /* 1226 * @tc.number: SUB_BMS_TOOL_ZLIB_0081 1227 * @tc.name: compressFileOutFileNull 1228 * @tc.desc: test compressFile when outFile is null 1229 */ 1230 it('compressFileOutFileNull', Level.LEVEL3, async function (done) { 1231 console.log("==================compressFileOutFileNull start=================="); 1232 let path1 = dir + "/compressFileOutFileNull.txt"; 1233 let fd = fileio.openSync(path1, 0o100 | 0o2, 0o666); 1234 await fileio.write(fd, infos).then(function (number) { 1235 console.info("fileio write data to file successfully :" + number); 1236 }).catch(function (err) { 1237 console.info("fileio write data to file failed with error:" + err); 1238 expect(err).assertFail(); 1239 }); 1240 try { 1241 await zlib.compressFile(path1, null, { 1242 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1243 }).then((data) => { 1244 console.log("compressFileOutFileNull invalid src file success!"); 1245 expect().assertFail(); 1246 }).catch((err) => { 1247 console.log("compressFileOutFileNull zipFile fail: " + JSON.stringify(err)); 1248 expect().assertFail(); 1249 }) 1250 } catch (err) { 1251 expect(err.code).assertEqual(PARAM_ERROR); 1252 } 1253 try { 1254 zlib.compressFile(path1, null, { 1255 level: zlib.CompressLevel.COMPRESS_LEVEL_NO_COMPRESSION 1256 }, (err, data) => { 1257 console.log("compressFile result"); 1258 expect().assertFail(); 1259 done(); 1260 }) 1261 } catch (err) { 1262 expect(err.code).assertEqual(PARAM_ERROR); 1263 done(); 1264 } 1265 console.log("==================compressFileOutFileNull end=================="); 1266 }) 1267 1268 /* 1269 * @tc.number: SUB_BMS_TOOL_ZLIB_0082 1270 * @tc.name: compressFileOptionNull 1271 * @tc.desc: test compressFile when option is null 1272 */ 1273 it('compressFileOptionNull', Level.LEVEL3, async function (done) { 1274 console.log("==================compressFileOptionNull start=================="); 1275 let path1 = dir + "/compressFileOptionNull.txt"; 1276 let zipDest1 = dir + "/compressFileOptionNull.zip"; 1277 let fd = fileio.openSync(path1, 0o100 | 0o2, 0o666); 1278 await fileio.write(fd, infos).then(function (number) { 1279 console.info("fileio write data to file successfully :" + number); 1280 }).catch(function (err) { 1281 console.info("fileio write data to file failed with error:" + err); 1282 expect(err).assertFail(); 1283 }); 1284 try { 1285 await zlib.compressFile(path1, zipDest1, null).then((data) => { 1286 console.log("compressFileOptionNull invalid src file success!"); 1287 expect().assertFail(); 1288 }).catch((err) => { 1289 console.log("compressFileOptionNull zipFile fail: " + JSON.stringify(err)); 1290 expect().assertFail(); 1291 }) 1292 } catch (err) { 1293 expect(err.code).assertEqual(PARAM_ERROR); 1294 } 1295 try { 1296 zlib.compressFile(path1, zipDest1, null, (err, data) => { 1297 console.log("compressFile result"); 1298 expect().assertFail(); 1299 done(); 1300 }) 1301 } catch (err) { 1302 expect(err.code).assertEqual(PARAM_ERROR); 1303 done(); 1304 } 1305 console.log("==================compressFileOptionNull end=================="); 1306 }) 1307 1308 /* 1309 * @tc.number: SUB_BMS_TOOL_ZLIB_0084 1310 * @tc.name: compressFileStrategyNull 1311 * @tc.desc: test compressFile when strategy is null 1312 */ 1313 it('compressFileStrategyNull', Level.LEVEL3, async function (done) { 1314 console.log("==================compressFileStrategyNull start=================="); 1315 let path1 = dir + "/compressFileStrategyNull.txt"; 1316 let zipDest1 = dir + "/compressFileStrategyNull.zip"; 1317 let fd = fileio.openSync(path1, 0o100 | 0o2, 0o666); 1318 await fileio.write(fd, infos).then(function (number) { 1319 console.info("fileio write data to file successfully :" + number); 1320 }).catch(function (err) { 1321 console.info("fileio write data to file failed with error:" + err); 1322 expect(err).assertFail(); 1323 }); 1324 try { 1325 await zlib.compressFile(path1, zipDest1, { 1326 strategy: null 1327 }).then((data) => { 1328 console.log("compressFileStrategyNull invalid src file success!"); 1329 expect().assertFail(); 1330 }).catch((err) => { 1331 console.log("compressFileStrategyNull zipFile fail: " + JSON.stringify(err)); 1332 expect().assertFail(); 1333 }) 1334 } catch (err) { 1335 expect(err.code).assertEqual(PARAM_ERROR); 1336 } 1337 try { 1338 zlib.compressFile(path1, zipDest1, { 1339 strategy: null 1340 }, (err, data) => { 1341 console.log("compressFile result"); 1342 expect().assertFail(); 1343 done(); 1344 }) 1345 } catch (err) { 1346 expect(err.code).assertEqual(PARAM_ERROR); 1347 done(); 1348 } 1349 console.log("==================compressFileOutFileNull end=================="); 1350 }) 1351 1352 /* 1353 * @tc.number: SUB_BMS_TOOL_ZLIB_0087 1354 * @tc.name: decompressFileTest 1355 * @tc.desc: test decompressFile when inFile and out file is valid 1356 */ 1357 it('decompressFileTest', Level.LEVEL2, async function (done) { 1358 console.log("==================decompressFileTest start=================="); 1359 let path = dir + "/decompressFileTest.txt"; 1360 let zipDest1 = dir + "/decompressFileTest1.zip"; 1361 let zipDest2 = dir + "/decompressFileTest2.zip"; 1362 let unzipdir1 = dir + "/decompressFileTest1"; 1363 let unzipdir2 = dir + "/decompressFileTest2"; 1364 let finalFile1 = unzipdir1 + "/decompressFileTest.txt"; 1365 let finalFile2 = unzipdir2 + "/decompressFileTest.txt"; 1366 let fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1367 await fileio.write(fd, infos).then(function (number) { 1368 console.info("decompressFileTest write data to file success " + JSON.stringify(number)); 1369 }).catch(function (err) { 1370 console.info("decompressFileTest write data to file failed with error:" + err); 1371 expect(err).assertFail(); 1372 }); 1373 await zlib.compressFile(path, zipDest1, { 1374 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1375 }).then(data => { 1376 console.info("compressFile success " + JSON.stringify(data)); 1377 let zipStat = fileio.statSync(zipDest1); 1378 let isFile = zipStat.isFile(); 1379 expect(isFile).assertTrue(); 1380 let srcSize = fileio.statSync(path).size; 1381 let destSize = zipStat.size; 1382 expect(srcSize > destSize).assertTrue(); 1383 expect(data).assertEqual(null); 1384 }).catch(err => { 1385 console.info("compressFile fail " + JSON.stringify(err)); 1386 expect(err).assertFail(); 1387 }) 1388 await zlib.compressFile(path, zipDest2, { 1389 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1390 }).then(data => { 1391 console.info("compressFile success " + JSON.stringify(data)); 1392 let zipStat = fileio.statSync(zipDest2); 1393 let isFile = zipStat.isFile(); 1394 expect(isFile).assertTrue(); 1395 let srcSize = fileio.statSync(path).size; 1396 let destSize = zipStat.size; 1397 expect(srcSize > destSize).assertTrue(); 1398 expect(data).assertEqual(null); 1399 }).catch(err => { 1400 console.info("compressFile fail " + JSON.stringify(err)); 1401 expect(err).assertFail(); 1402 }) 1403 await fileio.mkdir(unzipdir1).then(function () { 1404 console.info("decompressFileTest mkdir successfully"); 1405 }).catch(function (error) { 1406 console.info("decompressFileTest mkdir failed with error:" + error); 1407 expect(error).assertFail(); 1408 }); 1409 await zlib.decompressFile(zipDest1, unzipdir1, { 1410 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1411 }).then(data => { 1412 console.info("decompressFile success1 " + JSON.stringify(data)); 1413 let zipStat = fileio.statSync(finalFile1); 1414 let isFile = zipStat.isFile(); 1415 expect(isFile).assertTrue(); 1416 expect(data).assertEqual(null); 1417 }).catch(err => { 1418 console.info("decompressFile fail1 " + JSON.stringify(err)); 1419 expect(err).assertFail(); 1420 }) 1421 await fileio.mkdir(unzipdir2).then(function () { 1422 console.info("decompressFileTest mkdir successfully"); 1423 }).catch(function (error) { 1424 console.info("decompressFileTest mkdir failed with error:" + error); 1425 expect(error).assertFail(); 1426 }); 1427 zlib.decompressFile(zipDest2, unzipdir2, { 1428 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1429 }, (err, data) => { 1430 console.info("decompressFile success2 " + JSON.stringify(data)); 1431 console.info("decompressFile success2 " + JSON.stringify(err)); 1432 let zipStat = fileio.statSync(finalFile2); 1433 let isFile = zipStat.isFile(); 1434 expect(isFile).assertTrue(); 1435 expect(data).assertEqual(undefined); 1436 expect(err).assertEqual(null); 1437 done(); 1438 }) 1439 }) 1440 1441 /* 1442 * @tc.number: SUB_BMS_TOOL_ZLIB_0088 1443 * @tc.name: decompressFileInFileNotExist 1444 * @tc.desc: test decompressFile when inFile is not exist 1445 */ 1446 it('decompressFileInFileNotExist', Level.LEVEL3, async function (done) { 1447 console.log("==================decompressFileInFileNotExist start=================="); 1448 let zipDest = dir + "/noneexist.zip"; 1449 let unzipdir = dir + "/decompressFileInFileNotExist"; 1450 await fileio.mkdir(unzipdir).then(function () { 1451 console.info("fileio mkdir successfully"); 1452 }).catch(function (error) { 1453 console.info("fileio mkdir failed with error:" + error); 1454 expect(error).assertFail(); 1455 }); 1456 await zlib.decompressFile(zipDest, unzipdir, { 1457 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1458 }).then(data => { 1459 console.log("decompressFile data: " + data); 1460 expect(data).assertFail(null); 1461 done(); 1462 }).catch(err => { 1463 console.log("decompress fail: " + JSON.stringify(err)); 1464 expect(err.code).assertEqual(SRC_FILE_INVALID); 1465 done(); 1466 }) 1467 zlib.decompressFile(zipDest, unzipdir, { 1468 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1469 }, (err, data) => { 1470 expect(err.code).assertEqual(SRC_FILE_INVALID); 1471 expect(data).assertEqual(undefined); 1472 done(); 1473 }) 1474 console.log("==================decompressFileInFileNotExist end=================="); 1475 }) 1476 1477 /* 1478 * @tc.number: SUB_BMS_TOOL_ZLIB_0089 1479 * @tc.name: decompressFileInFileNull 1480 * @tc.desc: test decompressFile when inFile is null 1481 */ 1482 it('decompressFileInFileNull', Level.LEVEL3, async function (done) { 1483 console.log("==================decompressFileInFileNull start=================="); 1484 let unzipdir = dir + "/decompressFileInFileNull"; 1485 await fileio.mkdir(unzipdir).then(function () { 1486 console.info("fileio mkdir successfully"); 1487 }).catch(function (error) { 1488 console.info("fileio mkdir failed with error:" + error); 1489 expect(error).assertFail(); 1490 }); 1491 try { 1492 await zlib.decompressFile(null, unzipdir, { 1493 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1494 }).then(data => { 1495 console.log("decompressFile data: " + data); 1496 expect().assertFail(); 1497 }).catch(err => { 1498 console.log("decompress fail: " + JSON.stringify(err)); 1499 expect().assertFail(); 1500 }) 1501 } catch (err) { 1502 console.log("decompress fail: " + JSON.stringify(err)); 1503 expect(err.code).assertEqual(PARAM_ERROR); 1504 } 1505 try { 1506 zlib.decompressFile(null, unzipdir, { 1507 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1508 }, (err, data) => { 1509 expect().assertFail(); 1510 done(); 1511 }) 1512 } catch (err) { 1513 console.log("decompress fail: " + JSON.stringify(err)); 1514 expect(err.code).assertEqual(PARAM_ERROR); 1515 done(); 1516 } 1517 console.log("==================decompressFileInFileNull end=================="); 1518 }) 1519 1520 /* 1521 * @tc.number: SUB_BMS_TOOL_ZLIB_0091 1522 * @tc.name: decompressFileOutFileNull 1523 * @tc.desc: test decompressFile when outFile is null 1524 */ 1525 it('decompressFileOutFileNull', Level.LEVEL3, async function (done) { 1526 console.log("==================decompressFileOutFileNull start=================="); 1527 let path = dir + "/decompressFileOutFileNull.txt"; 1528 let zipDest1 = dir + "/decompressFileOutFileNull.zip"; 1529 let fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1530 await fileio.write(fd, infos).then(function (number) { 1531 console.info("decompressFileOutFileNull write data to file success " + JSON.stringify(number)); 1532 }).catch(function (err) { 1533 console.info("decompressFileOutFileNull write data to file failed with error:" + err); 1534 expect(err).assertFail(); 1535 }); 1536 await zlib.compressFile(path, zipDest1, { 1537 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1538 }).then(data => { 1539 console.info("compressFile success " + JSON.stringify(data)); 1540 let zipStat = fileio.statSync(zipDest1); 1541 let isFile = zipStat.isFile(); 1542 expect(isFile).assertTrue(); 1543 let srcSize = fileio.statSync(path).size; 1544 let destSize = zipStat.size; 1545 expect(srcSize > destSize).assertTrue(); 1546 expect(data).assertEqual(null); 1547 }).catch(err => { 1548 console.info("compressFile fail " + JSON.stringify(err)); 1549 expect(err).assertFail(); 1550 }) 1551 try { 1552 await zlib.decompressFile(zipDest1, null, { 1553 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1554 }).then(data => { 1555 console.log("decompressFile data: " + data); 1556 expect().assertFail(); 1557 }).catch(err => { 1558 console.log("decompress fail: " + JSON.stringify(err)); 1559 expect().assertFail(); 1560 }) 1561 } catch (err) { 1562 console.log("decompress fail: " + JSON.stringify(err)); 1563 expect(err.code).assertEqual(PARAM_ERROR); 1564 } 1565 try { 1566 zlib.decompressFile(zipDest1, null, { 1567 strategy: zlib.CompressStrategy.COMPRESS_STRATEGY_FIXED 1568 }, (err, data) => { 1569 expect().assertFail(); 1570 done(); 1571 }) 1572 } catch (err) { 1573 console.log("decompress fail: " + JSON.stringify(err)); 1574 expect(err.code).assertEqual(PARAM_ERROR); 1575 done(); 1576 } 1577 console.log("==================decompressFileOutFileNull end=================="); 1578 }) 1579 1580 /* 1581 * @tc.number: SUB_BMS_TOOL_ZLIB_0092 1582 * @tc.name: decompressFileOptionNull 1583 * @tc.desc: test decompressFile when option is null 1584 */ 1585 it('decompressFileOptionNull', Level.LEVEL3, async function (done) { 1586 console.log("==================decompressFileOptionNull start=================="); 1587 let path = dir + "/decompressFileOptionNull.txt"; 1588 let zipDest1 = dir + "/decompressFileOptionNull.zip"; 1589 let fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1590 await fileio.write(fd, infos).then(function (number) { 1591 console.info("SUB_BMS_TOOL_ZLIB_0087 write data to file success " + JSON.stringify(number)); 1592 }).catch(function (err) { 1593 console.info("SUB_BMS_TOOL_ZLIB_0087 write data to file failed with error:" + err); 1594 expect(err).assertFail(); 1595 }); 1596 await zlib.compressFile(path, zipDest1, { 1597 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1598 }).then(data => { 1599 console.info("compressFile success " + JSON.stringify(data)); 1600 let zipStat = fileio.statSync(zipDest1); 1601 let isFile = zipStat.isFile(); 1602 expect(isFile).assertTrue(); 1603 let srcSize = fileio.statSync(path).size; 1604 let destSize = zipStat.size; 1605 expect(srcSize > destSize).assertTrue(); 1606 expect(data).assertEqual(null); 1607 }).catch(err => { 1608 console.info("compressFile fail " + JSON.stringify(err)); 1609 expect(err).assertFail(); 1610 }) 1611 let unzipdir = dir + "/decompressFileOptionNull"; 1612 await fileio.mkdir(unzipdir).then(function () { 1613 console.info("fileio mkdir successfully"); 1614 }).catch(function (error) { 1615 console.info("fileio mkdir failed with error:" + error); 1616 expect(error).assertFail(); 1617 }); 1618 try { 1619 await zlib.decompressFile(zipDest1, unzipdir, null).then(data => { 1620 console.log("decompressFile data: " + data); 1621 expect().assertFail(); 1622 }).catch(err => { 1623 console.log("decompress fail: " + JSON.stringify(err)); 1624 expect().assertFail(); 1625 }) 1626 } catch (err) { 1627 console.log("decompress fail: " + JSON.stringify(err)); 1628 expect(err.code).assertEqual(PARAM_ERROR); 1629 } 1630 try { 1631 zlib.decompressFile(zipDest1, unzipdir, null, (err, data) => { 1632 expect().assertFail(); 1633 done(); 1634 }) 1635 } catch (err) { 1636 console.log("decompress fail: " + JSON.stringify(err)); 1637 expect(err.code).assertEqual(PARAM_ERROR); 1638 done(); 1639 } 1640 console.log("==================decompressFileOutFileNull end=================="); 1641 }) 1642 1643 /* 1644 * @tc.number: SUB_BMS_TOOL_ZLIB_0094 1645 * @tc.name: decompressFileStrategyNull 1646 * @tc.desc: test decompressFile when strategy is null 1647 */ 1648 it('decompressFileStrategyNull', Level.LEVEL3, async function (done) { 1649 console.log("==================decompressFileStrategyNull start=================="); 1650 let path = dir + "/decompressFileStrategyNull.txt"; 1651 let zipDest1 = dir + "/decompressFileStrategyNull.zip"; 1652 let fd = fileio.openSync(path, 0o100 | 0o2, 0o666); 1653 await fileio.write(fd, infos).then(function (number) { 1654 console.info("decompressFileStrategyNull write data to file success " + JSON.stringify(number)); 1655 }).catch(function (err) { 1656 console.info("decompressFileStrategyNull write data to file failed with error:" + err); 1657 expect(err).assertFail(); 1658 }); 1659 await zlib.compressFile(path, zipDest1, { 1660 level: zlib.CompressLevel.COMPRESS_LEVEL_DEFAULT_COMPRESSION 1661 }).then(data => { 1662 console.info("compressFile success " + JSON.stringify(data)); 1663 let zipStat = fileio.statSync(zipDest1); 1664 let isFile = zipStat.isFile(); 1665 expect(isFile).assertTrue(); 1666 let srcSize = fileio.statSync(path).size; 1667 let destSize = zipStat.size; 1668 expect(srcSize > destSize).assertTrue(); 1669 expect(data).assertEqual(null); 1670 }).catch(err => { 1671 console.info("compressFile fail " + JSON.stringify(err)); 1672 expect(err).assertFail(); 1673 }) 1674 let unzipdir = dir + "/decompressFileStrategyNull"; 1675 await fileio.mkdir(unzipdir).then(function () { 1676 console.info("fileio mkdir successfully"); 1677 }).catch(function (error) { 1678 console.info("fileio mkdir failed with error:" + error); 1679 expect(error).assertFail(); 1680 }); 1681 try { 1682 await zlib.decompressFile(zipDest1, unzipdir, { 1683 strategy: null 1684 }).then(data => { 1685 console.log("decompressFile data: " + data); 1686 expect().assertFail(); 1687 }).catch(err => { 1688 console.log("decompress fail: " + JSON.stringify(err)); 1689 expect().assertFail(); 1690 }) 1691 } catch (err) { 1692 console.log("decompress fail: " + JSON.stringify(err)); 1693 expect(err.code).assertEqual(PARAM_ERROR); 1694 } 1695 try { 1696 zlib.decompressFile(zipDest1, unzipdir, { 1697 strategy: null 1698 }, (err, data) => { 1699 expect().assertFail(); 1700 done(); 1701 }) 1702 } catch (err) { 1703 console.log("decompress fail: " + JSON.stringify(err)); 1704 expect(err.code).assertEqual(PARAM_ERROR); 1705 done(); 1706 } 1707 console.log("==================decompressFileStrategyNull end=================="); 1708 }) 1709 }) 1710} 1711 1712