xref: /test/xts/acts/bundlemanager/zlib/actszlibtest/ActsZlibTest.cpp

133     int err = Z_OK;

135     err = compress(compr, &comprLen, reinterpret_cast<const Bytef*>(HELLO), len);

136     fprintf(stderr, "compress error: %d\n", err);

137     ASSERT_EQ(err, Z_OK);

140     err = uncompress(uncompr, &uncomprLen, compr, comprLen);

141     fprintf(stderr, "uncompress error: %d\n", err);

142     ASSERT_EQ(err, Z_OK);

160     int err = Z_OK;

170         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

217     int err = Z_OK;

222     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

223     fprintf(stderr, "deflateInit result: %d\n", err);

224     ASSERT_EQ(err, Z_OK);

231         err = deflate(&c_stream, Z_NO_FLUSH);

232         fprintf(stderr, "deflate result: %d\n", err);

233         ASSERT_EQ(err, Z_OK);

238         err = deflate(&c_stream, Z_FINISH);

239         fprintf(stderr, "deflate result: %d\n", err);

240         if (err == Z_STREAM_END) {

243         ASSERT_EQ(err, Z_OK);

246     err = deflateEnd(&c_stream);

247     fprintf(stderr, "deflateEnd result: %d\n", err);

248     ASSERT_EQ(err, Z_OK);

266     int err = Z_OK;

275     err = inflateInit(&d_stream);

276     fprintf(stderr, "inflateInit result: %d\n", err);

277     ASSERT_EQ(err, Z_OK);

281         err = inflate(&d_stream, Z_NO_FLUSH);

282         if (err == Z_STREAM_END || err == Z_DATA_ERROR) {

285         fprintf(stderr, "inflate result: %d\n", err);

286         ASSERT_EQ(err, Z_OK);

309     int err = Z_OK;

314     err = deflateInit(&c_stream, Z_BEST_SPEED);

315     fprintf(stderr, "deflateInit result: %d\n", err);

316     ASSERT_EQ(err, Z_OK);

326     err = deflate(&c_stream, Z_NO_FLUSH);

327     fprintf(stderr, "deflate result: %d\n", err);

328     ASSERT_EQ(err, Z_OK);

335     err = deflate(&c_stream, Z_NO_FLUSH);

336     fprintf(stderr, "deflate result: %d\n", err);

337     ASSERT_EQ(err, Z_OK);

343     err = deflate(&c_stream, Z_NO_FLUSH);

344     ASSERT_EQ(err, Z_OK);

346     err = deflate(&c_stream, Z_FINISH);

347     ASSERT_EQ(err, Z_STREAM_END);

349     err = deflateEnd(&c_stream);

350     ASSERT_EQ(err, Z_OK);

369     int err = Z_OK;

377     err = inflateInit(&d_stream);

378     ASSERT_EQ(err, Z_OK);

383         err = inflate(&d_stream, Z_NO_FLUSH);

384         if (err == Z_STREAM_END || err == Z_DATA_ERROR) {

387         ASSERT_EQ(err, Z_OK);

390     err = inflateEnd(&d_stream);

391     ASSERT_EQ(err, Z_OK);

409     int err = Z_OK;

414     err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);

415     ASSERT_EQ(err, Z_OK);

421     err = deflate(&c_stream, Z_FULL_FLUSH);

422     ASSERT_EQ(err, Z_OK);

426     err = deflate(&c_stream, Z_FINISH);

427     if (err != Z_STREAM_END) {

428         ASSERT_EQ(err, Z_OK);

431     err = deflateEnd(&c_stream);

432     ASSERT_EQ(err, Z_OK);

451     int err = Z_OK;

459     err = inflateInit(&d_stream);

460     ASSERT_EQ(err, Z_OK);

490     int err = Z_OK;

494     err = deflateInit(&c_stream, Z_BEST_COMPRESSION);

495     ASSERT_EQ(err, Z_OK);

497     err = deflateSetDictionary(&c_stream,

499     ASSERT_EQ(err, Z_OK);

505     err = deflate(&c_stream, Z_FINISH);

506     ASSERT_EQ(err, Z_STREAM_END);

508     err = deflateEnd(&c_stream);

509     ASSERT_EQ(err, Z_OK);

528     int err = Z_OK;

536     err = inflateInit(&d_stream);

537     ASSERT_EQ(err, Z_OK);

541         err = inflate(&d_stream, Z_NO_FLUSH);

542         if (err == Z_STREAM_END) {

545         if (err == Z_NEED_DICT) {

546             err = inflateSetDictionary(

549         if (err == Z_DATA_ERROR) {

552         ASSERT_EQ(err, Z_OK);

555     err = inflateEnd(&d_stream);

556     ASSERT_EQ(err, Z_OK);

584     int err = Z_OK;

588     err = compress2(compr, &comprLen, reinterpret_cast<const Bytef*>(HELLO), outLen, Z_BEST_COMPRESSION);

589     fprintf(stderr, "compress2 Z_BEST_COMPRESSION result: %d\n", err);

590     ASSERT_EQ(err, Z_OK);

593     err = uncompress2(uncompr, &uncomprLen, compr, &comprLen);

594     fprintf(stderr, "uncompress2 Z_BEST_COMPRESSION result: %d\n", err);

595     ASSERT_EQ(err, Z_OK);

609     uLong err = Z_ERRNO;

613     err = adler32(0L, buf, 0);

614     fprintf(stderr, "adler32 result: %lu\n", err);

615     ASSERT_NE(err, Z_ERRNO);

617     err = adler32_z(0L, buf, 0);

618     fprintf(stderr, "adler32_z result: %lu\n", err);

619     ASSERT_NE(err, Z_ERRNO);

622     err = adler32_combine64(adler1, adler2, 0);

623     fprintf(stderr, "adler32_combine64 result: %lu\n", err);

624     ASSERT_NE(err, Z_ERRNO);

627     err = adler32_combine(adler1, adler2, 0);

628     fprintf(stderr, "adler32_combine result: %lu\n", err);

629     ASSERT_NE(err, Z_ERRNO);

650     int err = Z_OK;

656     err = deflateInit2_(&c_stream, Z_BEST_COMPRESSION, Z_DEFLATED, windowBits,

658     ASSERT_EQ(err, Z_OK);

662     err = deflateParams(&c_stream, memLevel, Z_DEFAULT_STRATEGY);

663     fprintf(stderr, "deflateParams result: %d\n", err);

664     ASSERT_EQ(err, Z_OK);

666     err = deflatePending(&c_stream, nullptr, bits);

667     fprintf(stderr, "deflatePending result: %d\n", err);

668     ASSERT_EQ(err, Z_OK);

670     err = deflateSetDictionary(&c_stream,

672     fprintf(stderr, "deflateGetDictionary result: %d\n", err);

673     ASSERT_EQ(err, Z_OK);

675     err = deflateGetDictionary(&c_stream, uncompr, nullptr);

676     fprintf(stderr, "deflateGetDictionary result: %d\n", err);

677     err = deflatePrime(&c_stream, EIGHT, ONE);

678     fprintf(stderr, "deflatePrime result: %d\n", err);

683     err = deflate(&c_stream, Z_FINISH);

684     ASSERT_EQ(err, Z_STREAM_END);

685     err = deflateEnd(&c_stream);

686     ASSERT_EQ(err, Z_OK);

688     err = deflateResetKeep(&c_stream);

689     fprintf(stderr, "deflateReset result: %d\n", err);

691     err = deflateReset(&c_stream);

692     fprintf(stderr, "deflateReset result: %d\n", err);

711     int err = Z_OK;

720     err = deflateInit_(&defstream, Z_DEFAULT_COMPRESSION,

722     fprintf(stderr, "deflateInit_ result: %d\n", err);

723     ASSERT_EQ(err, Z_OK);

730     err = deflateCopy(&defstream, &outStream);

731     fprintf(stderr, "deflateCopy result: %d\n", err);

744     uLong err = Z_ERRNO;

748     err = crc32(0L, buf, 0);

749     fprintf(stderr, "crc32 result: %lu\n", err);

750     ASSERT_NE(err, Z_ERRNO);

752     err = crc32_z(0L, buf, 0);

753     fprintf(stderr, "crc32_z result: %lu\n", err);

754     ASSERT_NE(err, Z_ERRNO);

757     err = crc32_combine64(crc1, crc2, 0);

758     fprintf(stderr, "crc32_combine64 result: %lu\n", err);

759     ASSERT_NE(err, Z_ERRNO);

761     err = crc32_combine(crc1, crc2, 0);

762     fprintf(stderr, "crc32_combine result: %lu\n", err);

763     ASSERT_NE(err, Z_ERRNO);

766     err = adler32_combine(crc1, crc2, 0);

767     fprintf(stderr, "adler32_combine result: %lu\n", err);

768     ASSERT_NE(err, Z_ERRNO);

794     int err = Z_OK;

801     err = gzbuffer(file, BUFFER_SIZE);

802     ASSERT_EQ(err, Z_OK);

808         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

856     int err = Z_OK;

864         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

884     int err = Z_OK;

889     err = gzfread(HELLO, len, len, file);

890     ASSERT_EQ(err, 1);

907     int err = Z_OK;

912     err = gzfwrite(HELLO, len, len, file);

913     ASSERT_EQ(err, len);

929     int err = Z_OK;

933     err = gzgetc(file);

934     ASSERT_TRUE(err == 'h');

953     int err = gzgetc(file);

954     ASSERT_TRUE(err == 'h');

974     int err = Z_OK;

978     err = gzgetc_(file);

979     ASSERT_TRUE(err == 'h');

1021     int err = Z_OK;

1026     err = gzoffset64(file);

1027     ASSERT_TRUE(err != Z_OK);

1041     int err = Z_OK;

1048         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

1058     int err = Z_OK;

1065         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

1112     char err;

1116     err = gzputc(file, 'h');

1117     ASSERT_TRUE(err == 'h');

1152     int err = Z_OK;

1161         fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));

1192     int err = Z_OK;

1196     err = gzrewind(file);

1197     ASSERT_TRUE(err == -1);

1210     long err = 0L;

1217     err = gzseek(file, 1L, SEEK_CUR);

1220     err = gzseek64(file, 1L, SEEK_CUR);

1222     ASSERT_TRUE(err == 1L);

1237     int err = Z_OK;

1241     err = gzsetparams(file, Z_DEFAULT_COMPRESSION, Z_DEFAULT_STRATEGY);

1242     ASSERT_TRUE(err == Z_OK);

1297     int err = TestGzPrintf(file, ", %s!", "hello");

1298     fprintf(stderr, "gzvprintf result: %d\n", err);

1318     int err = gzwrite(file, HELLO, len);

1319     ASSERT_EQ(err, len);

1334     int err = Z_OK;

1346     err = inflateBackInit_(

1348     ASSERT_EQ(err, Z_OK);

1349     if (err != Z_OK) {

1355     err = inflateBack(&strm, pull, nullptr, push, &strm);

1356     ASSERT_TRUE(err != Z_OK);

1357     err = inflateBackEnd(&strm);

1358     ASSERT_EQ(err, Z_OK);

1375     unsigned long err;

1384     err = inflateCodesUsed(&d_stream);

1385     ASSERT_TRUE(err != Z_OK);

1397     int err = Z_OK;

1398     err = inflate(nullptr, 0);

1399     ASSERT_TRUE(err == Z_STREAM_ERROR);

1400     err = inflateEnd(nullptr);

1401     ASSERT_TRUE(err == Z_STREAM_ERROR);

1402     err = inflateCopy(nullptr, nullptr);

1403     ASSERT_TRUE(err == Z_STREAM_ERROR);

1420     int err = Z_OK;

1428     err = inflateInit(&d_stream);

1429     ASSERT_EQ(err, Z_OK);

1432     err = inflate(&d_stream, Z_NO_FLUSH);

1433     err = inflateGetDictionary(&d_stream, uncompr, nullptr);

1434     ASSERT_EQ(err, Z_OK);

1436     err = inflateEnd(&d_stream);

1437     ASSERT_EQ(err, Z_OK);

1458     int err = Z_OK;

1468     err = inflateInit2(&strm, 1);

1469     ASSERT_TRUE(err != Z_OK);

1478     err = inflateGetHeader(&strm, &head);

1479     ASSERT_TRUE(err != Z_DATA_ERROR);

1491     int err = Z_OK;

1508     err = inflateInit(&strm);

1509     ASSERT_TRUE(err == Z_OK);

1510     err = inflatePrime(&strm, 5, 31);

1511     ASSERT_TRUE(err == Z_OK);

1512     err = inflatePrime(&strm, -1, 0);

1513     ASSERT_TRUE(err == Z_OK);

1514     err = inflateSetDictionary(&strm, nullptr, 0);

1515     ASSERT_TRUE(err == Z_STREAM_ERROR);

1516     err = inflateEnd(&strm);

1517     ASSERT_TRUE(err == Z_OK);

1520     err = inflateInit_(&strm, ZLIB_VERSION - 1, static_cast<int>(sizeof(z_stream)));

1521     ASSERT_TRUE(err == Z_VERSION_ERROR);

1523     err = inflateInit2_(&strm, windowBits, ZLIB_VERSION - 1, static_cast<int>(sizeof(z_stream)));

1524     ASSERT_TRUE(err == Z_VERSION_ERROR);

1590     int err = Z_OK;

1599     err = inflateInit(&d_stream);

1600     ASSERT_EQ(err, Z_OK);

1604     err = inflateReset(&d_stream);

1605     ASSERT_TRUE(err == Z_OK);

1607     err = inflateResetKeep(&d_stream);

1608     ASSERT_TRUE(err == Z_OK);

1609     err = inflateInit2(&d_stream, windowBits);

1611     err = inflateReset2(&d_stream, windowBits);

1612     ASSERT_TRUE(err == Z_OK);

1629     int err = Z_OK;

1637     err = inflateInit(&d_stream);

1638     ASSERT_EQ(err, Z_OK);

1643     err = inflateEnd(&d_stream);

1644     ASSERT_EQ(err, Z_OK);

1663     int err = Z_OK;

1671     err = inflateInit(&d_stream);

1672     ASSERT_EQ(err, Z_OK);

1675     err = inflateSyncPoint(&d_stream);

1676     ASSERT_EQ(err, Z_OK);

1695     int err = Z_OK;

1703     err = inflateInit(&d_stream);

1704     ASSERT_EQ(err, Z_OK);

1707     err = inflateUndermine(&d_stream, 1);

1708     ASSERT_EQ(err, Z_DATA_ERROR);

1727     int err = Z_OK;

1735     err = inflateInit(&d_stream);

1736     ASSERT_EQ(err, Z_OK);

1739     err = inflateValidate(&d_stream, 1);

1740     ASSERT_EQ(err, Z_OK);

1773     const char* err;

1774     err = zError(Z_DATA_ERROR);

1775     ASSERT_EQ(err, "data error");

1786     static const char* err;

1787     err = zlibVersion();

1788     ASSERT_EQ(err, myVersion);

1807     int err = gzeof(file);

1808     fprintf(stderr, "gzeof result: %d\n", err);

Indexes created Thu Nov 07 10:32:03 CST 2024