File Manager

003 File Manager

Current Path: /usr/src/contrib/libarchive/libarchive/test

usr / src / contrib / libarchive / libarchive / test /

📁 ..
📄 README(2.49 KB)
📄 main.c(77.6 KB)
📄 read_open_memory.c(6.3 KB)
📄 test.h(1.9 KB)
📄 test_acl_nfs4.c(8.49 KB)
📄 test_acl_pax.c(15.87 KB)
📄 test_acl_pax_nfs4.tar.uu(7.62 KB)
📄 test_acl_pax_posix1e.tar.uu(6.93 KB)
📄 test_acl_platform_nfs4.c(34.03 KB)
📄 test_acl_platform_posix1e.c(16.11 KB)
📄 test_acl_posix1e.c(7.13 KB)
📄 test_acl_text.c(14.72 KB)
📄 test_archive_api_feature.c(2.22 KB)
📄 test_archive_clear_error.c(1.69 KB)
📄 test_archive_cmdline.c(5.35 KB)
📄 test_archive_digest.c(5.36 KB)
📄 test_archive_getdate.c(3.82 KB)
📄 test_archive_match_owner.c(9.59 KB)
📄 test_archive_match_path.c(14.43 KB)
📄 test_archive_match_time.c(42.76 KB)
📄 test_archive_pathmatch.c(14.17 KB)
📄 test_archive_read_add_passphrase.c(9.14 KB)
📄 test_archive_read_close_twice.c(1.71 KB)
📄 test_archive_read_close_twice_open_fd.c(1.97 KB)
📄 test_archive_read_close_twice_open_filename.c(2.06 KB)
📄 test_archive_read_multiple_data_objects.c(11.93 KB)
📄 test_archive_read_next_header_empty.c(3.91 KB)
📄 test_archive_read_next_header_raw.c(2.31 KB)
📄 test_archive_read_open2.c(3.44 KB)
📄 test_archive_read_set_filter_option.c(1.96 KB)
📄 test_archive_read_set_format_option.c(2.46 KB)
📄 test_archive_read_set_option.c(2.5 KB)
📄 test_archive_read_set_options.c(4 KB)
📄 test_archive_read_support.c(5.12 KB)
📄 test_archive_set_error.c(1.84 KB)
📄 test_archive_string.c(10.79 KB)
📄 test_archive_string_conversion.c(25.02 KB)
📄 test_archive_string_conversion.txt.Z.uu(157.5 KB)
📄 test_archive_write_add_filter_by_name.c(6.45 KB)
📄 test_archive_write_set_filter_option.c(1.96 KB)
📄 test_archive_write_set_format_by_name.c(8.61 KB)
📄 test_archive_write_set_format_filter_by_ext.c(7.16 KB)
📄 test_archive_write_set_format_option.c(2.47 KB)
📄 test_archive_write_set_option.c(2.5 KB)
📄 test_archive_write_set_options.c(4 KB)
📄 test_archive_write_set_passphrase.c(3.1 KB)
📄 test_bad_fd.c(1.71 KB)
📄 test_compat_bzip2.c(3.21 KB)
📄 test_compat_bzip2_1.tbz.uu(1.18 KB)
📄 test_compat_bzip2_2.tbz.uu(395 B)
📄 test_compat_cpio.c(4.15 KB)
📄 test_compat_cpio_1.cpio.uu(879 B)
📄 test_compat_gtar.c(5.45 KB)
📄 test_compat_gtar_1.tar.uu(13.83 KB)
📄 test_compat_gtar_2.tar.uu(2.8 KB)
📄 test_compat_gzip.c(3.5 KB)
📄 test_compat_gzip_1.tgz.uu(1.16 KB)
📄 test_compat_gzip_2.tgz.uu(406 B)
📄 test_compat_lz4.c(4.75 KB)
📄 test_compat_lz4_1.tar.lz4.uu(572 B)
📄 test_compat_lz4_2.tar.lz4.uu(642 B)
📄 test_compat_lz4_3.tar.lz4.uu(406 B)
📄 test_compat_lz4_B4.tar.lz4.uu(407.84 KB)
📄 test_compat_lz4_B4BD.tar.lz4.uu(407.84 KB)
📄 test_compat_lz4_B4BDBX.tar.lz4.uu(408.19 KB)
📄 test_compat_lz4_B5.tar.lz4.uu(139.72 KB)
📄 test_compat_lz4_B5BD.tar.lz4.uu(139.72 KB)
📄 test_compat_lz4_B6.tar.lz4.uu(72.29 KB)
📄 test_compat_lz4_B6BD.tar.lz4.uu(72.29 KB)
📄 test_compat_lz4_B7.tar.lz4.uu(55.43 KB)
📄 test_compat_lz4_B7BD.tar.lz4.uu(55.43 KB)
📄 test_compat_lzip.c(4.62 KB)
📄 test_compat_lzip_1.tlz.uu(437 B)
📄 test_compat_lzip_2.tlz.uu(359 B)
📄 test_compat_lzma.c(5.09 KB)
📄 test_compat_lzma_1.tlz.uu(352 B)
📄 test_compat_lzma_2.tlz.uu(274 B)
📄 test_compat_lzma_3.tlz.uu(274 B)
📄 test_compat_lzop.c(5.09 KB)
📄 test_compat_lzop_1.tar.lzo.uu(1.67 KB)
📄 test_compat_lzop_2.tar.lzo.uu(2.17 KB)
📄 test_compat_lzop_3.tar.lzo.uu(1.74 KB)
📄 test_compat_mac-1.tar.Z.uu(2.11 KB)
📄 test_compat_mac-2.tar.Z.uu(988 B)
📄 test_compat_mac.c(8.21 KB)
📄 test_compat_perl_archive_tar.c(2.63 KB)
📄 test_compat_perl_archive_tar.tar.uu(2.81 KB)
📄 test_compat_plexus_archiver_tar.c(2.75 KB)
📄 test_compat_plexus_archiver_tar.tar.uu(2.81 KB)
📄 test_compat_solaris_pax_sparse.c(6.76 KB)
📄 test_compat_solaris_pax_sparse_1.pax.Z.uu(3.07 KB)
📄 test_compat_solaris_pax_sparse_2.pax.Z.uu(3.07 KB)
📄 test_compat_solaris_tar_acl.c(10.4 KB)
📄 test_compat_solaris_tar_acl.tar.uu(9.7 KB)
📄 test_compat_star_acl.c(12.21 KB)
📄 test_compat_star_acl_nfs4.tar.uu(13.83 KB)
📄 test_compat_star_acl_posix1e.tar.uu(13.83 KB)
📄 test_compat_tar_hardlink.c(4.22 KB)
📄 test_compat_tar_hardlink_1.tar.uu(2.12 KB)
📄 test_compat_uudecode.c(2.72 KB)
📄 test_compat_uudecode_large.c(2.47 KB)
📄 test_compat_uudecode_large.tar.Z.uu(65.67 KB)
📄 test_compat_xz.c(3.04 KB)
📄 test_compat_xz_1.txz.uu(559 B)
📄 test_compat_zip.c(17.39 KB)
📄 test_compat_zip_1.zip.uu(726 B)
📄 test_compat_zip_2.zip.uu(324 B)
📄 test_compat_zip_3.zip.uu(952 B)
📄 test_compat_zip_4.zip.uu(1.31 KB)
📄 test_compat_zip_5.zip.uu(14.47 KB)
📄 test_compat_zip_6.zip.uu(472 B)
📄 test_compat_zip_7.xps.uu(21.46 KB)
📄 test_compat_zip_8.zip.uu(226 B)
📄 test_compat_zstd.c(3.17 KB)
📄 test_compat_zstd_1.tar.zst.uu(553 B)
📄 test_compat_zstd_2.tar.zst.uu(297 B)
📄 test_empty_write.c(4.38 KB)
📄 test_entry.c(37.69 KB)
📄 test_entry_strmode.c(2.89 KB)
📄 test_extattr_freebsd.c(5.21 KB)
📄 test_filter_count.c(2.64 KB)
📄 test_fuzz.c(15.12 KB)
📄 test_fuzz.cab.uu(2.81 KB)
📄 test_fuzz.lzh.uu(9 KB)
📄 test_fuzz_1.iso.Z.uu(29.68 KB)
📄 test_gnutar_filename_encoding.c(12.14 KB)
📄 test_link_resolver.c(7.24 KB)
📄 test_open_failure.c(7.24 KB)
📄 test_open_fd.c(4.76 KB)
📄 test_open_file.c(3.95 KB)
📄 test_open_filename.c(7.26 KB)
📄 test_pax_filename_encoding.c(20.46 KB)
📄 test_pax_filename_encoding.tar.uu(6.95 KB)
📄 test_pax_xattr_header.c(4.99 KB)
📄 test_pax_xattr_header_all.tar.uu(4.18 KB)
📄 test_pax_xattr_header_libarchive.tar.uu(4.19 KB)
📄 test_pax_xattr_header_schily.tar.uu(4.18 KB)
📄 test_rar_multivolume_multiple_files.part1.rar.uu(9.71 KB)
📄 test_rar_multivolume_multiple_files.part2.rar.uu(9.71 KB)
📄 test_rar_multivolume_multiple_files.part3.rar.uu(9.71 KB)
📄 test_rar_multivolume_multiple_files.part4.rar.uu(9.71 KB)
📄 test_rar_multivolume_multiple_files.part5.rar.uu(9.71 KB)
📄 test_rar_multivolume_multiple_files.part6.rar.uu(6.92 KB)
📄 test_rar_multivolume_single_file.part1.rar.uu(9.44 KB)
📄 test_rar_multivolume_single_file.part2.rar.uu(9.44 KB)
📄 test_rar_multivolume_single_file.part3.rar.uu(8.67 KB)
📄 test_rar_multivolume_uncompressed_files.part01.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part02.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part03.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part04.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part05.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part06.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part07.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part08.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part09.rar.uu(17.93 KB)
📄 test_rar_multivolume_uncompressed_files.part10.rar.uu(4.33 KB)
📄 test_read_data_large.c(4.34 KB)
📄 test_read_disk.c(5.66 KB)
📄 test_read_disk_directory_traversals.c(64.08 KB)
📄 test_read_disk_entry_from_file.c(2.75 KB)
📄 test_read_extract.c(6.43 KB)
📄 test_read_file_nonexistent.c(1.6 KB)
📄 test_read_filter_compress.c(3.08 KB)
📄 test_read_filter_grzip.c(2.69 KB)
📄 test_read_filter_grzip.tar.grz.uu(317 B)
📄 test_read_filter_lrzip.c(2.69 KB)
📄 test_read_filter_lrzip.tar.lrz.uu(472 B)
📄 test_read_filter_lzop.c(3 KB)
📄 test_read_filter_lzop.tar.lzo.uu(510 B)
📄 test_read_filter_lzop_multiple_parts.c(3.13 KB)
📄 test_read_filter_lzop_multiple_parts.tar.lzo.uu(5.24 KB)
📄 test_read_filter_program.c(3.35 KB)
📄 test_read_filter_program_signature.c(3.93 KB)
📄 test_read_filter_uudecode.c(6.24 KB)
📄 test_read_format_7zip.c(29.56 KB)
📄 test_read_format_7zip_bcj2_bzip2.7z.uu(19.17 KB)
📄 test_read_format_7zip_bcj2_copy_1.7z.uu(37.04 KB)
📄 test_read_format_7zip_bcj2_copy_2.7z.uu(37.06 KB)
📄 test_read_format_7zip_bcj2_copy_lzma.7z.uu(34.24 KB)
📄 test_read_format_7zip_bcj2_deflate.7z.uu(18.77 KB)
📄 test_read_format_7zip_bcj2_lzma1_1.7z.uu(17.19 KB)
📄 test_read_format_7zip_bcj2_lzma1_2.7z.uu(14.38 KB)
📄 test_read_format_7zip_bcj2_lzma2_1.7z.uu(17.19 KB)
📄 test_read_format_7zip_bcj2_lzma2_2.7z.uu(14.39 KB)
📄 test_read_format_7zip_bcj_bzip2.7z.uu(16.84 KB)
📄 test_read_format_7zip_bcj_copy.7z.uu(36.97 KB)
📄 test_read_format_7zip_bcj_deflate.7z.uu(16.47 KB)
📄 test_read_format_7zip_bcj_lzma1.7z.uu(14.68 KB)
📄 test_read_format_7zip_bcj_lzma2.7z.uu(14.68 KB)
📄 test_read_format_7zip_bzip2.7z.uu(2.09 KB)
📄 test_read_format_7zip_copy.7z.uu(266 B)
📄 test_read_format_7zip_copy_2.7z.uu(488 B)
📄 test_read_format_7zip_deflate.7z.uu(2 KB)
📄 test_read_format_7zip_delta4_lzma1.7z.uu(24.46 KB)
📄 test_read_format_7zip_delta4_lzma2.7z.uu(24.47 KB)
📄 test_read_format_7zip_delta_lzma1.7z.uu(16.81 KB)
📄 test_read_format_7zip_delta_lzma2.7z.uu(16.82 KB)
📄 test_read_format_7zip_empty_archive.7z.uu(101 B)
📄 test_read_format_7zip_empty_file.7z.uu(160 B)
📄 test_read_format_7zip_encryption.7z.uu(256 B)
📄 test_read_format_7zip_encryption_data.c(3.01 KB)
📄 test_read_format_7zip_encryption_header.7z.uu(333 B)
📄 test_read_format_7zip_encryption_header.c(3.06 KB)
📄 test_read_format_7zip_encryption_partially.7z.uu(368 B)
📄 test_read_format_7zip_encryption_partially.c(3.67 KB)
📄 test_read_format_7zip_lzma1.7z.uu(2.05 KB)
📄 test_read_format_7zip_lzma1_2.7z.uu(355 B)
📄 test_read_format_7zip_lzma1_lzma2.7z.uu(447 B)
📄 test_read_format_7zip_lzma2.7z.uu(2.06 KB)
📄 test_read_format_7zip_malformed.7z.uu(127 B)
📄 test_read_format_7zip_malformed.c(2.58 KB)
📄 test_read_format_7zip_malformed2.7z.uu(128 B)
📄 test_read_format_7zip_packinfo_digests.7z.uu(266 B)
📄 test_read_format_7zip_packinfo_digests.c(3.5 KB)
📄 test_read_format_7zip_ppmd.7z.uu(14.05 KB)
📄 test_read_format_7zip_symbolic_name.7z.uu(317 B)
📄 test_read_format_ar.ar.uu(480 B)
📄 test_read_format_ar.c(3.92 KB)
📄 test_read_format_cab.c(12.99 KB)
📄 test_read_format_cab_1.cab.uu(411 B)
📄 test_read_format_cab_2.cab.uu(383 B)
📄 test_read_format_cab_3.cab.uu(445 B)
📄 test_read_format_cab_filename.c(6.16 KB)
📄 test_read_format_cab_filename_cp932.cab.uu(255 B)
📄 test_read_format_cpio_afio.c(4.97 KB)
📄 test_read_format_cpio_bin.c(3.25 KB)
📄 test_read_format_cpio_bin_Z.c(2.74 KB)
📄 test_read_format_cpio_bin_be.c(2.61 KB)
📄 test_read_format_cpio_bin_be.cpio.uu(276 B)
📄 test_read_format_cpio_bin_bz2.c(2.6 KB)
📄 test_read_format_cpio_bin_gz.c(2.69 KB)
📄 test_read_format_cpio_bin_le.c(2.61 KB)
📄 test_read_format_cpio_bin_le.cpio.uu(266 B)
📄 test_read_format_cpio_bin_lzip.c(2.76 KB)
📄 test_read_format_cpio_bin_lzma.c(2.71 KB)
📄 test_read_format_cpio_bin_xz.c(3.12 KB)
📄 test_read_format_cpio_filename.c(28.75 KB)
📄 test_read_format_cpio_filename_cp866.cpio.uu(757 B)
📄 test_read_format_cpio_filename_eucjp.cpio.uu(757 B)
📄 test_read_format_cpio_filename_koi8r.cpio.uu(757 B)
📄 test_read_format_cpio_filename_utf8_jp.cpio.uu(759 B)
📄 test_read_format_cpio_filename_utf8_ru.cpio.uu(759 B)
📄 test_read_format_cpio_odc.c(3.44 KB)
📄 test_read_format_cpio_svr4_bzip2_rpm.c(4.62 KB)
📄 test_read_format_cpio_svr4_bzip2_rpm.rpm.uu(2.71 KB)
📄 test_read_format_cpio_svr4_gzip.c(2.74 KB)
📄 test_read_format_cpio_svr4_gzip_rpm.c(4.62 KB)
📄 test_read_format_cpio_svr4_gzip_rpm.rpm.uu(2.63 KB)
📄 test_read_format_cpio_svr4c_Z.c(2.84 KB)
📄 test_read_format_empty.c(2.08 KB)
📄 test_read_format_gtar_filename.c(16.85 KB)
📄 test_read_format_gtar_filename_cp866.tar.Z.uu(448 B)
📄 test_read_format_gtar_filename_eucjp.tar.Z.uu(448 B)
📄 test_read_format_gtar_filename_koi8r.tar.Z.uu(440 B)
📄 test_read_format_gtar_gz.c(2.75 KB)
📄 test_read_format_gtar_lzma.c(3.17 KB)
📄 test_read_format_gtar_sparse.c(8.39 KB)
📄 test_read_format_gtar_sparse_1_13.tar.uu(82.73 KB)
📄 test_read_format_gtar_sparse_1_17.tar.uu(82.73 KB)
📄 test_read_format_gtar_sparse_1_17_posix00.tar.uu(96.52 KB)
📄 test_read_format_gtar_sparse_1_17_posix01.tar.uu(82.74 KB)
📄 test_read_format_gtar_sparse_1_17_posix10.tar.uu(82.74 KB)
📄 test_read_format_gtar_sparse_1_17_posix10_modified.tar.uu(82.75 KB)
📄 test_read_format_gtar_sparse_skip_entry.c(5.13 KB)
📄 test_read_format_gtar_sparse_skip_entry.tar.Z.uu(750 B)
📄 test_read_format_iso.iso.Z.uu(1.32 KB)
📄 test_read_format_iso_2.iso.Z.uu(1.98 KB)
📄 test_read_format_iso_Z.c(3.85 KB)
📄 test_read_format_iso_joliet.iso.Z.uu(3.71 KB)
📄 test_read_format_iso_joliet_by_nero.iso.Z.uu(3.74 KB)
📄 test_read_format_iso_joliet_long.iso.Z.uu(4.03 KB)
📄 test_read_format_iso_joliet_rockridge.iso.Z.uu(3.84 KB)
📄 test_read_format_iso_multi_extent.c(3.85 KB)
📄 test_read_format_iso_multi_extent.iso.Z.uu(3.78 KB)
📄 test_read_format_iso_rockridge.iso.Z.uu(12.23 KB)
📄 test_read_format_iso_rockridge_ce.iso.Z.uu(3.53 KB)
📄 test_read_format_iso_rockridge_new.iso.Z.uu(12.35 KB)
📄 test_read_format_iso_rockridge_rr_moved.iso.Z.uu(18.13 KB)
📄 test_read_format_iso_xorriso.c(8.47 KB)
📄 test_read_format_iso_xorriso.iso.Z.uu(3.53 KB)
📄 test_read_format_iso_zisofs.iso.Z.uu(3.56 KB)
📄 test_read_format_isojoliet_bz2.c(5.82 KB)
📄 test_read_format_isojoliet_long.c(5.69 KB)
📄 test_read_format_isojoliet_rr.c(7.16 KB)
📄 test_read_format_isojoliet_versioned.c(3.66 KB)
📄 test_read_format_isorr_bz2.c(8.89 KB)
📄 test_read_format_isorr_ce.c(8.11 KB)
📄 test_read_format_isorr_new_bz2.c(8.92 KB)
📄 test_read_format_isorr_rr_moved.c(11.53 KB)
📄 test_read_format_isozisofs_bz2.c(7.96 KB)
📄 test_read_format_lha.c(10.27 KB)
📄 test_read_format_lha_bugfix_0.c(2.99 KB)
📄 test_read_format_lha_bugfix_0.lzh.uu(998 B)
📄 test_read_format_lha_filename.c(7.76 KB)
📄 test_read_format_lha_filename_cp932.lzh.uu(275 B)
📄 test_read_format_lha_filename_utf16.c(5.55 KB)
📄 test_read_format_lha_filename_utf16.lzh.uu(1.03 KB)
📄 test_read_format_lha_header0.lzh.uu(529 B)
📄 test_read_format_lha_header1.lzh.uu(629 B)
📄 test_read_format_lha_header2.lzh.uu(629 B)
📄 test_read_format_lha_header3.lzh.uu(807 B)
📄 test_read_format_lha_lh0.lzh.uu(645 B)
📄 test_read_format_lha_lh6.lzh.uu(629 B)
📄 test_read_format_lha_lh7.lzh.uu(629 B)
📄 test_read_format_lha_withjunk.lzh.uu(650 B)
📄 test_read_format_mtree.c(34.82 KB)
📄 test_read_format_mtree.mtree.uu(2.29 KB)
📄 test_read_format_mtree_crash747.c(1.95 KB)
📄 test_read_format_mtree_crash747.mtree.bz2.uu(212 B)
📄 test_read_format_mtree_nomagic.mtree.uu(505 B)
📄 test_read_format_mtree_nomagic2.mtree.uu(432 B)
📄 test_read_format_mtree_nomagic3.mtree.uu(432 B)
📄 test_read_format_mtree_noprint.mtree.uu(115 B)
📄 test_read_format_pax_bz2.c(3.19 KB)
📄 test_read_format_rar.c(156.59 KB)
📄 test_read_format_rar.rar.uu(482 B)
📄 test_read_format_rar5.c(44.49 KB)
📄 test_read_format_rar5_arm.rar.uu(55.32 KB)
📄 test_read_format_rar5_arm_filter_on_window_boundary.rar.uu(408 B)
📄 test_read_format_rar5_blake2.rar.uu(935 B)
📄 test_read_format_rar5_block_size_is_too_small.rar.uu(372 B)
📄 test_read_format_rar5_compressed.rar.uu(640 B)
📄 test_read_format_rar5_different_solid_window_size.rar.uu(4.28 KB)
📄 test_read_format_rar5_different_window_size.rar.uu(40.73 KB)
📄 test_read_format_rar5_different_winsize_on_merge.rar.uu(822 B)
📄 test_read_format_rar5_distance_overflow.rar.uu(392 B)
📄 test_read_format_rar5_extra_field_version.rar.uu(452 B)
📄 test_read_format_rar5_fileattr.rar.uu(635 B)
📄 test_read_format_rar5_hardlink.rar.uu(221 B)
📄 test_read_format_rar5_invalid_dict_reference.rar.uu(417 B)
📄 test_read_format_rar5_leftshift1.rar.uu(393 B)
📄 test_read_format_rar5_leftshift2.rar.uu(203 B)
📄 test_read_format_rar5_multiarchive.part01.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part02.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part03.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part04.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part05.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part06.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part07.rar.uu(20.71 KB)
📄 test_read_format_rar5_multiarchive.part08.rar.uu(12.44 KB)
📄 test_read_format_rar5_multiarchive_solid.part01.rar.uu(17.98 KB)
📄 test_read_format_rar5_multiarchive_solid.part02.rar.uu(17.98 KB)
📄 test_read_format_rar5_multiarchive_solid.part03.rar.uu(17.98 KB)
📄 test_read_format_rar5_multiarchive_solid.part04.rar.uu(4.48 KB)
📄 test_read_format_rar5_multiple_files.rar.uu(2.27 KB)
📄 test_read_format_rar5_multiple_files_solid.rar.uu(982 B)
📄 test_read_format_rar5_nonempty_dir_stream.rar.uu(402 B)
📄 test_read_format_rar5_owner.rar.uu(322 B)
📄 test_read_format_rar5_readtables_overflow.rar.uu(786 B)
📄 test_read_format_rar5_solid.rar.uu(1.46 KB)
📄 test_read_format_rar5_stored.rar.uu(186 B)
📄 test_read_format_rar5_stored_manyfiles.rar.uu(3.54 KB)
📄 test_read_format_rar5_symlink.rar.uu(316 B)
📄 test_read_format_rar5_truncated_huff.rar.uu(281 B)
📄 test_read_format_rar5_win32.rar.uu(4.04 KB)
📄 test_read_format_rar_binary_data.rar.uu(1.42 MB)
📄 test_read_format_rar_compress_best.rar.uu(16.41 KB)
📄 test_read_format_rar_compress_normal.rar.uu(19.69 KB)
📄 test_read_format_rar_encryption_data.c(3.46 KB)
📄 test_read_format_rar_encryption_data.rar.uu(315 B)
📄 test_read_format_rar_encryption_header.c(3.06 KB)
📄 test_read_format_rar_encryption_header.rar.uu(365 B)
📄 test_read_format_rar_encryption_partially.c(3.53 KB)
📄 test_read_format_rar_encryption_partially.rar.uu(302 B)
📄 test_read_format_rar_invalid1.c(2.03 KB)
📄 test_read_format_rar_invalid1.rar.uu(138 B)
📄 test_read_format_rar_multi_lzss_blocks.rar.uu(26.71 KB)
📄 test_read_format_rar_multivolume.part0001.rar.uu(80.75 KB)
📄 test_read_format_rar_multivolume.part0002.rar.uu(80.75 KB)
📄 test_read_format_rar_multivolume.part0003.rar.uu(80.75 KB)
📄 test_read_format_rar_multivolume.part0004.rar.uu(12.4 KB)
📄 test_read_format_rar_noeof.rar.uu(142 B)
📄 test_read_format_rar_ppmd_lzss_conversion.rar.uu(237.77 KB)
📄 test_read_format_rar_ppmd_use_after_free.rar.uu(479 B)
📄 test_read_format_rar_ppmd_use_after_free2.rar.uu(460 B)
📄 test_read_format_rar_sfx.exe.uu(133.92 KB)
📄 test_read_format_rar_subblock.rar.uu(250 B)
📄 test_read_format_rar_unicode.rar.uu(967 B)
📄 test_read_format_rar_windows.rar.uu(1.12 KB)
📄 test_read_format_raw.bufr.uu(5.56 KB)
📄 test_read_format_raw.c(6.44 KB)
📄 test_read_format_raw.data.Z.uu(68 B)
📄 test_read_format_raw.data.gz.uu(107 B)
📄 test_read_format_raw.data.uu(62 B)
📄 test_read_format_tar.c(24.86 KB)
📄 test_read_format_tar_concatenated.c(3.46 KB)
📄 test_read_format_tar_concatenated.tar.uu(4.19 KB)
📄 test_read_format_tar_empty_filename.c(2.81 KB)
📄 test_read_format_tar_empty_filename.tar.uu(2.12 KB)
📄 test_read_format_tar_empty_pax.c(2.61 KB)
📄 test_read_format_tar_empty_pax.tar.Z.uu(467 B)
📄 test_read_format_tar_empty_with_gnulabel.c(2.26 KB)
📄 test_read_format_tar_empty_with_gnulabel.tar.uu(13.84 KB)
📄 test_read_format_tar_filename.c(14.37 KB)
📄 test_read_format_tar_filename_koi8r.tar.Z.uu(692 B)
📄 test_read_format_tbz.c(2.69 KB)
📄 test_read_format_tgz.c(2.72 KB)
📄 test_read_format_tlz.c(2.82 KB)
📄 test_read_format_txz.c(3.01 KB)
📄 test_read_format_tz.c(2.84 KB)
📄 test_read_format_ustar_filename.c(19.57 KB)
📄 test_read_format_ustar_filename_cp866.tar.Z.uu(370 B)
📄 test_read_format_ustar_filename_eucjp.tar.Z.uu(376 B)
📄 test_read_format_ustar_filename_koi8r.tar.Z.uu(362 B)
📄 test_read_format_warc.c(3.64 KB)
📄 test_read_format_warc.warc.uu(1.24 KB)
📄 test_read_format_xar.c(44.73 KB)
📄 test_read_format_zip.c(36.61 KB)
📄 test_read_format_zip.zip.uu(647 B)
📄 test_read_format_zip_7075_utf8_paths.c(3.75 KB)
📄 test_read_format_zip_7075_utf8_paths.zip.uu(1.08 KB)
📄 test_read_format_zip_7z_lzma.zip.uu(2.55 KB)
📄 test_read_format_zip_bz2_hang.zip.uu(138 B)
📄 test_read_format_zip_bzip2.zipx.uu(1003 B)
📄 test_read_format_zip_bzip2_multi.zipx.uu(5.68 KB)
📄 test_read_format_zip_comment_stored.c(2.93 KB)
📄 test_read_format_zip_comment_stored_1.zip.uu(560 B)
📄 test_read_format_zip_comment_stored_2.zip.uu(33.02 KB)
📄 test_read_format_zip_encryption_data.c(3.48 KB)
📄 test_read_format_zip_encryption_data.zip.uu(1.39 KB)
📄 test_read_format_zip_encryption_header.c(3.06 KB)
📄 test_read_format_zip_encryption_header.zip.uu(1.81 KB)
📄 test_read_format_zip_encryption_partially.c(3.53 KB)
📄 test_read_format_zip_encryption_partially.zip.uu(964 B)
📄 test_read_format_zip_extra_padding.c(3.74 KB)
📄 test_read_format_zip_extra_padding.zip.uu(271 B)
📄 test_read_format_zip_filename.c(42.68 KB)
📄 test_read_format_zip_filename_cp866.zip.uu(481 B)
📄 test_read_format_zip_filename_cp932.zip.uu(391 B)
📄 test_read_format_zip_filename_koi8r.zip.uu(481 B)
📄 test_read_format_zip_filename_utf8_jp.zip.uu(766 B)
📄 test_read_format_zip_filename_utf8_ru.zip.uu(517 B)
📄 test_read_format_zip_filename_utf8_ru2.zip.uu(502 B)
📄 test_read_format_zip_high_compression.c(4.93 KB)
📄 test_read_format_zip_high_compression.zip.uu(932 B)
📄 test_read_format_zip_jar.c(2.36 KB)
📄 test_read_format_zip_jar.jar.uu(215 B)
📄 test_read_format_zip_length_at_end.zip.uu(321 B)
📄 test_read_format_zip_lzma.zipx.uu(1010 B)
📄 test_read_format_zip_lzma_alone_leak.zipx.uu(178 B)
📄 test_read_format_zip_lzma_multi.zipx.uu(5.58 KB)
📄 test_read_format_zip_lzma_stream_end.zipx.uu(1002 B)
📄 test_read_format_zip_mac_metadata.c(4.85 KB)
📄 test_read_format_zip_mac_metadata.zip.uu(902 B)
📄 test_read_format_zip_malformed.c(2.49 KB)
📄 test_read_format_zip_malformed1.zip.uu(140 B)
📄 test_read_format_zip_msdos.c(4.87 KB)
📄 test_read_format_zip_msdos.zip.uu(1.2 KB)
📄 test_read_format_zip_nested.c(3.61 KB)
📄 test_read_format_zip_nested.zip.uu(842 B)
📄 test_read_format_zip_nofiletype.c(2.68 KB)
📄 test_read_format_zip_nofiletype.zip.uu(330 B)
📄 test_read_format_zip_padded.c(3.22 KB)
📄 test_read_format_zip_padded1.zip.uu(599 B)
📄 test_read_format_zip_padded2.zip.uu(741 B)
📄 test_read_format_zip_padded3.zip.uu(861 B)
📄 test_read_format_zip_ppmd8.zipx.uu(879 B)
📄 test_read_format_zip_ppmd8_crash_1.zipx.uu(118 B)
📄 test_read_format_zip_ppmd8_crash_2.zipx.uu(118 B)
📄 test_read_format_zip_ppmd8_multi.zipx.uu(4.9 KB)
📄 test_read_format_zip_sfx.c(2.66 KB)
📄 test_read_format_zip_sfx.uu(1.91 KB)
📄 test_read_format_zip_symlink.zip.uu(475 B)
📄 test_read_format_zip_traditional_encryption_data.c(6.72 KB)
📄 test_read_format_zip_traditional_encryption_data.zip.uu(615 B)
📄 test_read_format_zip_ux.zip.uu(280 B)
📄 test_read_format_zip_winzip_aes.c(5.69 KB)
📄 test_read_format_zip_winzip_aes128.zip.uu(3.87 KB)
📄 test_read_format_zip_winzip_aes256.zip.uu(3.88 KB)
📄 test_read_format_zip_winzip_aes256_large.zip.uu(132.06 KB)
📄 test_read_format_zip_winzip_aes256_stored.zip.uu(9.47 KB)
📄 test_read_format_zip_winzip_aes_large.c(8.91 KB)
📄 test_read_format_zip_with_invalid_traditional_eocd.c(2.45 KB)
📄 test_read_format_zip_with_invalid_traditional_eocd.zip.uu(684 B)
📄 test_read_format_zip_xz_multi.zipx.uu(7.42 KB)
📄 test_read_format_zip_zip64.c(4.37 KB)
📄 test_read_format_zip_zip64a.zip.uu(260 B)
📄 test_read_format_zip_zip64b.zip.uu(248 B)
📄 test_read_large.c(3.67 KB)
📄 test_read_large_splitted_rar_aa.uu(53.84 KB)
📄 test_read_large_splitted_rar_ab.uu(53.84 KB)
📄 test_read_large_splitted_rar_ac.uu(53.84 KB)
📄 test_read_large_splitted_rar_ad.uu(53.84 KB)
📄 test_read_large_splitted_rar_ae.uu(22.49 KB)
📄 test_read_pax_truncated.c(10.35 KB)
📄 test_read_pax_xattr_rht_security_selinux.c(2.56 KB)
📄 test_read_pax_xattr_rht_security_selinux.tar.uu(13.84 KB)
📄 test_read_pax_xattr_schily.c(2.88 KB)
📄 test_read_pax_xattr_schily.tar.uu(13.83 KB)
📄 test_read_position.c(4.14 KB)
📄 test_read_set_format.c(8.39 KB)
📄 test_read_splitted_rar_aa.uu(160 B)
📄 test_read_splitted_rar_ab.uu(160 B)
📄 test_read_splitted_rar_ac.uu(160 B)
📄 test_read_splitted_rar_ad.uu(68 B)
📄 test_read_too_many_filters.c(2.08 KB)
📄 test_read_too_many_filters.gz.uu(573 B)
📄 test_read_truncated.c(5.13 KB)
📄 test_read_truncated_filter.c(5.18 KB)
📄 test_sparse_basic.c(17.67 KB)
📄 test_splitted_rar_seek_support_aa.uu(9.44 KB)
📄 test_splitted_rar_seek_support_ab.uu(9.44 KB)
📄 test_splitted_rar_seek_support_ac.uu(8.37 KB)
📄 test_tar_filenames.c(5.05 KB)
📄 test_tar_large.c(8.08 KB)
📄 test_ustar_filename_encoding.c(12.12 KB)
📄 test_ustar_filenames.c(5.71 KB)
📄 test_warn_missing_hardlink_target.c(1.85 KB)
📄 test_write_disk.c(12.62 KB)
📄 test_write_disk_appledouble.c(7.95 KB)
📄 test_write_disk_appledouble.cpio.gz.uu(558 B)
📄 test_write_disk_failures.c(2.48 KB)
📄 test_write_disk_hardlink.c(7.45 KB)
📄 test_write_disk_hfs_compression.c(9.93 KB)
📄 test_write_disk_hfs_compression.tgz.uu(108.83 KB)
📄 test_write_disk_lookup.c(4.94 KB)
📄 test_write_disk_mac_metadata.c(7.03 KB)
📄 test_write_disk_mac_metadata.tar.gz.uu(678 B)
📄 test_write_disk_no_hfs_compression.c(8.01 KB)
📄 test_write_disk_no_hfs_compression.tgz.uu(106.69 KB)
📄 test_write_disk_perms.c(17.58 KB)
📄 test_write_disk_secure.c(11.75 KB)
📄 test_write_disk_secure744.c(3.09 KB)
📄 test_write_disk_secure745.c(2.9 KB)
📄 test_write_disk_secure746.c(4.61 KB)
📄 test_write_disk_sparse.c(8.72 KB)
📄 test_write_disk_symlink.c(9.42 KB)
📄 test_write_disk_times.c(5.86 KB)
📄 test_write_filter_b64encode.c(6.75 KB)
📄 test_write_filter_bzip2.c(9.76 KB)
📄 test_write_filter_compress.c(3.36 KB)
📄 test_write_filter_gzip.c(10.73 KB)
📄 test_write_filter_gzip_timestamp.c(4.34 KB)
📄 test_write_filter_lrzip.c(4.75 KB)
📄 test_write_filter_lz4.c(13.55 KB)
📄 test_write_filter_lzip.c(9.29 KB)
📄 test_write_filter_lzma.c(9.52 KB)
📄 test_write_filter_lzop.c(9.75 KB)
📄 test_write_filter_program.c(4.72 KB)
📄 test_write_filter_uuencode.c(6.74 KB)
📄 test_write_filter_xz.c(9.72 KB)
📄 test_write_filter_zstd.c(9.67 KB)
📄 test_write_format_7zip.c(19.63 KB)
📄 test_write_format_7zip_empty.c(9.93 KB)
📄 test_write_format_7zip_large.c(5.74 KB)
📄 test_write_format_ar.c(7.65 KB)
📄 test_write_format_cpio.c(8.99 KB)
📄 test_write_format_cpio_empty.c(2.68 KB)
📄 test_write_format_cpio_newc.c(7.94 KB)
📄 test_write_format_cpio_odc.c(9.1 KB)
📄 test_write_format_gnutar.c(10.03 KB)
📄 test_write_format_gnutar_filenames.c(5.32 KB)
📄 test_write_format_iso9660.c(40.42 KB)
📄 test_write_format_iso9660_boot.c(9.73 KB)
📄 test_write_format_iso9660_empty.c(7.22 KB)
📄 test_write_format_iso9660_filename.c(12.4 KB)
📄 test_write_format_iso9660_zisofs.c(28.81 KB)
📄 test_write_format_mtree.c(9.68 KB)
📄 test_write_format_mtree_absolute_path.c(3.81 KB)
📄 test_write_format_mtree_classic.c(6.5 KB)
📄 test_write_format_mtree_classic_indent.c(6.71 KB)
📄 test_write_format_mtree_fflags.c(4.13 KB)
📄 test_write_format_mtree_no_separator.c(3.95 KB)
📄 test_write_format_mtree_quoted_filename.c(3.3 KB)
📄 test_write_format_pax.c(9.52 KB)
📄 test_write_format_raw.c(4.7 KB)
📄 test_write_format_raw_b64.c(2.9 KB)
📄 test_write_format_shar_empty.c(2.21 KB)
📄 test_write_format_tar.c(4.44 KB)
📄 test_write_format_tar_empty.c(2.82 KB)
📄 test_write_format_tar_sparse.c(10.68 KB)
📄 test_write_format_tar_ustar.c(13.19 KB)
📄 test_write_format_tar_v7tar.c(9.15 KB)
📄 test_write_format_warc.c(5.56 KB)
📄 test_write_format_warc_empty.c(4.64 KB)
📄 test_write_format_xar.c(10.92 KB)
📄 test_write_format_xar_empty.c(4.58 KB)
📄 test_write_format_zip.c(32.25 KB)
📄 test_write_format_zip_compression_store.c(16.05 KB)
📄 test_write_format_zip_empty.c(3.37 KB)
📄 test_write_format_zip_empty_zip64.c(4.62 KB)
📄 test_write_format_zip_file.c(9.87 KB)
📄 test_write_format_zip_file_zip64.c(11.52 KB)
📄 test_write_format_zip_large.c(13.63 KB)
📄 test_write_format_zip_zip64.c(2.62 KB)
📄 test_write_open_memory.c(3.21 KB)
📄 test_write_read_format_zip.c(26.34 KB)
📄 test_xattr_platform.c(3.57 KB)
📄 test_zip_filename_encoding.c(17.47 KB)

Editing: test_read_format_rar.c

/*-
 * Copyright (c) 2003-2007 Tim Kientzle
 * Copyright (c) 2011 Andres Mejia
 * Copyright (c) 2011-2012 Michihiro NAKAJIMA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "test.h"

#include <locale.h>

DEFINE_TEST(test_read_format_rar_set_format)
{
    struct archive *a;
    struct archive_entry *ae;
    const char reffile[] = "test_read_format_rar.rar";

extract_reference_file(reffile);
    assert((a = archive_read_new()) != NULL);
    assertA(0 == archive_read_support_filter_all(a));
    assertA(0 == archive_read_set_format(a, ARCHIVE_FORMAT_RAR));
    assertA(0 == archive_read_open_filename(a, reffile, 10240));
    assertA(0 == archive_read_next_header(a, &ae));
    assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
    assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_basic)
{
  char buff[64];
  const char reffile[] = "test_read_format_rar.rar";
  const char test_txt[] = "test text document\r\n";
  int size = sizeof(test_txt)-1;
  struct archive_entry *ae;
  struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(20, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testlink", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("test.txt", archive_entry_symlink(ae));
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(20, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Fourth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Fifth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testemptydir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));
  assertEqualInt(5, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_subblock)
{
  char buff[64];
  const char reffile[] = "test_read_format_rar_subblock.rar";
  const char test_txt[] = "test text document\r\n";
  int size = sizeof(test_txt)-1;
  struct archive_entry *ae;
  struct archive *a;

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));
  assertEqualInt(1, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_noeof)
{
  char buff[64];
  const char reffile[] = "test_read_format_rar_noeof.rar";
  const char test_txt[] = "test text document\r\n";
  int size = sizeof(test_txt)-1;
  struct archive_entry *ae;
  struct archive *a;

DEFINE_TEST(test_read_format_rar_unicode_UTF8)
{
  char buff[30];
  const char reffile[] = "test_read_format_rar_unicode.rar";
  const char test_txt[] = "kanji";
  struct archive_entry *ae;
  struct archive *a;

if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
	skipping("en_US.UTF-8 locale not available on this system.");
	return;
  }

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
#if defined(__APPLE__)
#define f1name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
      "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82\xA9"\
      "\xE3\x83\xAB\xE3\x82\xBF\xE3\x82\x99/\xE6\x96\xB0\xE8\xA6\x8F"\
      "\xE3\x83\x86\xE3\x82\xAD\xE3\x82\xB9\xE3\x83\x88 "\
      "\xE3\x83\x88\xE3\x82\x99\xE3\x82\xAD\xE3\x83\xA5\xE3\x83\xA1"\
      "\xE3\x83\xB3\xE3\x83\x88.txt" /* NFD */
#else
#define f1name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
      "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82\xA9"\
      "\xE3\x83\xAB\xE3\x83\x80/\xE6\x96\xB0\xE8\xA6\x8F"\
      "\xE3\x83\x86\xE3\x82\xAD\xE3\x82\xB9\xE3\x83\x88 "\
      "\xE3\x83\x89\xE3\x82\xAD\xE3\x83\xA5\xE3\x83\xA1"\
      "\xE3\x83\xB3\xE3\x83\x88.txt" /* NFC */
#endif
  assertEqualUTF8String(f1name, archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
#if defined(__APPLE__)
#define f2name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
      "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"\
      "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"\
      "\xE6\xBC\xA2\xE5\xAD\x97.txt" /* NFD */
#else
#define f2name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
      "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"\
      "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"\
      "\xE6\xBC\xA2\xE5\xAD\x97.txt" /* NFC */
#endif
  assertEqualUTF8String(f2name, archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(5, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualIntA(a, 5, archive_read_data(a, buff, 5));
  assertEqualMem(buff, test_txt, 5);
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
#if defined(__APPLE__)
#define f3name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
      "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82"\
      "\xA9\xE3\x83\xAB\xE3\x82\xBF\xE3\x82\x99" /* NFD */
#else
#define f3name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
      "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82"\
      "\xA9\xE3\x83\xAB\xE3\x83\x80" /* NFC */
#endif
  assertEqualUTF8String(f3name, archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));

/* Fourth header. */
  assertA(0 == archive_read_next_header(a, &ae));
#if defined(__APPLE__)
#define f4name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88" /* NFD */
#else
#define f4name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88" /* NFC */
#endif
  assertEqualUTF8String(f4name, archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));

/* Fifth header, which has a symbolic-link name in multi-byte characters. */
  assertA(0 == archive_read_next_header(a, &ae));
#if defined(__APPLE__)
#define f5name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
      "\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB" /* NFD */
#else
#define f5name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
      "\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB" /* NFC */
#endif
  assertEqualUTF8String(f5name, archive_entry_pathname(ae));
  assertEqualUTF8String(
      "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"
      "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"
      "\xE6\xBC\xA2\xE5\xAD\x97.txt", archive_entry_symlink(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41453, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/* Sixth header */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualUTF8String(
    "abcdefghijklmnopqrs\xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88.txt",
    archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33204, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 16, archive_read_data(a, buff, sizeof(buff)));

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));
  assertEqualInt(6, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_unicode_CP932)
{
  char buff[30];
  const char reffile[] = "test_read_format_rar_unicode.rar";
  const char test_txt[] = "kanji";
  struct archive_entry *ae;
  struct archive *a;

if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
    NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
	skipping("CP932 locale not available on this system.");
	return;
  }

extract_reference_file(reffile);
  assert((a = archive_read_new()) != NULL);
  assertA(0 == archive_read_support_filter_all(a));
  assertA(0 == archive_read_support_format_all(a));
  /* Specify the charset of symbolic-link file name. */
  if (ARCHIVE_OK != archive_read_set_options(a, "rar:hdrcharset=UTF-8")) {
	skipping("This system cannot convert character-set"
	    " from UTF-8 to CP932.");
	assertEqualInt(ARCHIVE_OK, archive_read_free(a));
	return;
  }
  assertA(0 == archive_read_open_filename(a, reffile, 10240));

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("\x95\x5c\x82\xbe\x82\xe6/\x90\x56\x82\xb5\x82\xa2"
      "\x83\x74\x83\x48\x83\x8b\x83\x5f/\x90\x56\x8b\x4b\x83\x65\x83\x4c"
      "\x83\x58\x83\x67 \x83\x68\x83\x4c\x83\x85\x83\x81\x83\x93\x83\x67.txt",
      archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("\x95\x5c\x82\xbe\x82\xe6/\x8a\xbf\x8e\x9a"
      "\x92\xb7\x82\xa2\x83\x74\x83\x40\x83\x43\x83\x8b\x96\xbc\x6c"
      "\x6f\x6e\x67\x2d\x66\x69\x6c\x65\x6e\x61\x6d\x65\x2d\x69\x6e"
      "\x2d\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(5, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(5 == archive_read_data(a, buff, 5));
  assertEqualMem(buff, test_txt, 5);

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("\x95\x5c\x82\xbe\x82\xe6/"
      "\x90\x56\x82\xb5\x82\xa2\x83\x74\x83\x48\x83\x8b\x83\x5f",
      archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Fourth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("\x95\x5c\x82\xbe\x82\xe6", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Fifth header, which has a symbolic-link name in multi-byte characters. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("\x95\x5c\x82\xbe\x82\xe6/"
      "\x83\x74\x83\x40\x83\x43\x83\x8B", archive_entry_pathname(ae));
  assertEqualString("\x8a\xbf\x8e\x9a"
      "\x92\xb7\x82\xa2\x83\x74\x83\x40\x83\x43\x83\x8b\x96\xbc\x6c"
      "\x6f\x6e\x67\x2d\x66\x69\x6c\x65\x6e\x61\x6d\x65\x2d\x69\x6e"
      "\x2d\x8a\xbf\x8e\x9a.txt", archive_entry_symlink(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41453, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/* Sixth header */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualUTF8String(
    "abcdefghijklmnopqrs\x83\x65\x83\x58\x83\x67.txt",
    archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33204, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 16, archive_read_data(a, buff, sizeof(buff)));

DEFINE_TEST(test_read_format_rar_compress_normal)
{
 const char reffile[] = "test_read_format_rar_compress_normal.rar";
 char file1_buff[20111];
 int file1_size = sizeof(file1_buff);
 const char file1_test_txt[] = " \n"
 "\n"
 "</BODY>\n"
 "</HTML>";
 char file2_buff[20];
 int file2_size = sizeof(file2_buff);
 const char file2_test_txt[] = "test text document\r\n";
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file1_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
  assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
                 file1_test_txt, sizeof(file1_test_txt) - 1);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testlink", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
  assertEqualIntA(a, 0, archive_read_data(a, file1_buff, 30));

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file2_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
  assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
                 file2_test_txt, sizeof(file2_test_txt) - 1);

/* Fourth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/LibarchiveAddingTest.html",
                    archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file1_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
  assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
                 file1_test_txt, sizeof(file1_test_txt) - 1);

/* Fifth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Sixth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testemptydir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* This test is for sufficiently large files that would have been compressed
 * using multiple lzss blocks.
 */
DEFINE_TEST(test_read_format_rar_multi_lzss_blocks)
{
 const char reffile[] = "test_read_format_rar_multi_lzss_blocks.rar";
 const char test_txt[] = "-bottom: 0in\"> \n\n</BODY>\n</HTML>";
 int size = 20131111, offset = 0;
 char buff[64];
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
 assertA(0 == archive_read_next_header(a, &ae));
 assertEqualString("multi_lzss_blocks_test.txt", archive_entry_pathname(ae));
 assertA((int)archive_entry_mtime(ae));
 assertA((int)archive_entry_ctime(ae));
 assertA((int)archive_entry_atime(ae));
 assertEqualInt(size, archive_entry_size(ae));
 assertEqualInt(33188, archive_entry_mode(ae));
 assertEqualInt(archive_entry_is_encrypted(ae), 0);
 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 while (offset + (int)sizeof(buff) < size)
 {
 assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 offset += sizeof(buff);
 }
 assertA(size - offset == archive_read_data(a, buff, size - offset));
 assertEqualMem(buff, test_txt, size - offset);

DEFINE_TEST(test_read_format_rar_compress_best)
{
 const char reffile[] = "test_read_format_rar_compress_best.rar";
 char file1_buff[20111];
 int file1_size = sizeof(file1_buff);
 const char file1_test_txt[] = " \n"
 "\n"
 "</BODY>\n"
 "</HTML>";
 char file2_buff[20];
 int file2_size = sizeof(file2_buff);
 const char file2_test_txt[] = "test text document\r\n";
 struct archive_entry *ae;
 struct archive *a;

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testlink", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
  assertEqualIntA(a, 0, archive_read_data(a, file1_buff, 30));

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file2_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
  assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
                 file2_test_txt, sizeof(file2_test_txt) - 1);

/* This is a test for RAR files compressed using a technique where compression
 * switches back and forth to and from ppmd and lzss decoding.
 */
DEFINE_TEST(test_read_format_rar_ppmd_lzss_conversion)
{
 const char reffile[] = "test_read_format_rar_ppmd_lzss_conversion.rar";
 const char test_txt[] = "gin-bottom: 0in\"> \n\n</BODY>\n</HTML>";
 int size = 241647978, offset = 0;
 char buff[64];
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
 assertA(0 == archive_read_next_header(a, &ae));
 assertEqualString("ppmd_lzss_conversion_test.txt",
 archive_entry_pathname(ae));
 assertA((int)archive_entry_mtime(ae));
 assertA((int)archive_entry_ctime(ae));
 assertA((int)archive_entry_atime(ae));
 assertEqualInt(size, archive_entry_size(ae));
 assertEqualInt(33188, archive_entry_mode(ae));
 assertEqualInt(archive_entry_is_encrypted(ae), 0);
 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 while (offset + (int)sizeof(buff) < size)
 {
 assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 offset += sizeof(buff);
 }
 assertA(size - offset == archive_read_data(a, buff, size - offset));
 assertEqualMem(buff, test_txt, size - offset);

DEFINE_TEST(test_read_format_rar_binary)
{
  const char reffile[] = "test_read_format_rar_binary_data.rar";
  char *file1_buff = malloc(1048576);
  int file1_size = 1048576;
  const char file1_test_txt[] = "\x37\xef\xb2\xbe\x33\xf6\xcc\xcb\xee\x2a\x10"
                                "\x9d\x2e\x01\xe9\xf6\xf9\xe5\xe6\x67\x0c\x2b"
                                "\xd8\x6b\xa0\x26\x9a\xf7\x93\x87\x42\xf1\x08"
                                "\x42\xdc\x9b\x76\x91\x20\xa4\x01\xbe\x67\xbd"
                                "\x08\x74\xde\xec";
  char file2_buff[32618];
  int file2_size = sizeof(file2_buff);
  const char file2_test_txt[] = "\x00\xee\x78\x00\x00\x4d\x45\x54\x41\x2d\x49"
                                "\x4e\x46\x2f\x6d\x61\x6e\x69\x66\x65\x73\x74"
                                "\x2e\x78\x6d\x6c\x50\x4b\x05\x06\x00\x00\x00"
                                "\x00\x12\x00\x12\x00\xaa\x04\x00\x00\xaa\x7a"
                                "\x00\x00\x00\x00";
  struct archive_entry *ae;
  struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("random_data.bin", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file1_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
  assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
                 file1_test_txt, sizeof(file1_test_txt) - 1);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.odt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file2_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
  assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
                 file2_test_txt, sizeof(file2_test_txt) - 1);

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));
  assertEqualInt(2, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));

free(file1_buff);
}

DEFINE_TEST(test_read_format_rar_windows)
{
  char buff[441];
  const char reffile[] = "test_read_format_rar_windows.rar";
  const char test_txt[] = "test text file\r\n";
  int size = sizeof(test_txt)-1;
  struct archive_entry *ae;
  struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testshortcut.lnk", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(sizeof(buff), archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));

DEFINE_TEST(test_read_format_rar_multivolume)
{
 const char *reffiles[] =
 {
 "test_read_format_rar_multivolume.part0001.rar",
 "test_read_format_rar_multivolume.part0002.rar",
 "test_read_format_rar_multivolume.part0003.rar",
 "test_read_format_rar_multivolume.part0004.rar",
 NULL
 };
 int file1_size = 241647978, offset = 0;
 char buff[64];
 const char file1_test_txt[] = "gin-bottom: 0in\"> \n\n</BODY>\n"
 "</HTML>";
 char file2_buff[20111];
 int file2_size = sizeof(file2_buff);
 const char file2_test_txt[] = " \n"
 "\n"
 "</BODY>\n"
 "</HTML>";
 char file3_buff[20];
 int file3_size = sizeof(file3_buff);
 const char file3_test_txt[] = "test text document\r\n";
 struct archive_entry *ae;
 struct archive *a;

extract_reference_files(reffiles);
  assert((a = archive_read_new()) != NULL);
  assertA(0 == archive_read_support_filter_all(a));
  assertA(0 == archive_read_support_format_all(a));
  assertA(0 == archive_read_open_filenames(a, reffiles, 10240));

/* First header. */
 assertA(0 == archive_read_next_header(a, &ae));
 assertEqualString("ppmd_lzss_conversion_test.txt",
 archive_entry_pathname(ae));
 assertA((int)archive_entry_mtime(ae));
 assertA((int)archive_entry_ctime(ae));
 assertA((int)archive_entry_atime(ae));
 assertEqualInt(file1_size, archive_entry_size(ae));
 assertEqualInt(33188, archive_entry_mode(ae));
 assertEqualInt(archive_entry_is_encrypted(ae), 0);
 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 while (offset + (int)sizeof(buff) < file1_size)
 {
 assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 offset += sizeof(buff);
 }
 assertA(file1_size - offset ==
 archive_read_data(a, buff, file1_size - offset));
 assertEqualMem(buff, file1_test_txt, file1_size - offset);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file2_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
  assertEqualMem(&file2_buff[file2_size - sizeof(file2_test_txt) + 1],
                 file2_test_txt, sizeof(file2_test_txt) - 1);

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testlink", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
  assertEqualIntA(a, 0, archive_read_data(a, file2_buff, 30));

/* Fourth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file3_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file3_size == archive_read_data(a, file3_buff, file3_size));
  assertEqualMem(&file3_buff[file3_size + 1 - sizeof(file3_test_txt)],
                 file3_test_txt, sizeof(file3_test_txt) - 1);

/* Fifth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/LibarchiveAddingTest.html",
                    archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file2_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
  assertEqualMem(&file2_buff[file2_size - sizeof(file2_test_txt) + 1],
                 file2_test_txt, sizeof(file2_test_txt) - 1);

/* Sixth header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Seventh header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testemptydir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));
  assertEqualInt(7, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_multivolume_skip)
{
  const char *reffiles[] =
  {
    "test_read_format_rar_multivolume.part0001.rar",
    "test_read_format_rar_multivolume.part0002.rar",
    "test_read_format_rar_multivolume.part0003.rar",
    "test_read_format_rar_multivolume.part0004.rar",
    NULL
  };
  int file1_size = 241647978;
  int file2_size = 20111;
  int file3_size = 20;
  struct archive_entry *ae;
  struct archive *a;

DEFINE_TEST(test_read_format_rar_sfx)
{
  char buff[441];
  const char reffile[] = "test_read_format_rar_sfx.exe";
  const char test_txt[] = "test text file\r\n";
  int size = sizeof(test_txt)-1;
  struct archive_entry *ae;
  struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testshortcut.lnk", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(sizeof(buff), archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));

/* Third header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(16, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(size == archive_read_data(a, buff, size));
  assertEqualMem(buff, test_txt, size);

DEFINE_TEST(test_read_format_rar_multivolume_stored_file)
{
 const char *reffiles[] =
 {
 "test_rar_multivolume_single_file.part1.rar",
 "test_rar_multivolume_single_file.part2.rar",
 "test_rar_multivolume_single_file.part3.rar",
 NULL
 };
 char file_buff[20111];
 int file_size = sizeof(file_buff);
 const char file_test_txt[] = " \n"
 "\n"
 "</BODY>\n"
 "</HTML>";
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertA(file_size == archive_read_data(a, file_buff, file_size));
  assertEqualMem(&file_buff[file_size - sizeof(file_test_txt) + 1],
                 file_test_txt, sizeof(file_test_txt) - 1);

DEFINE_TEST(test_read_format_rar_multivolume_stored_file_skip)
{
  const char *reffiles[] =
  {
    "test_rar_multivolume_single_file.part1.rar",
    "test_rar_multivolume_single_file.part2.rar",
    "test_rar_multivolume_single_file.part3.rar",
    NULL
  };
  int file_size = 20111;
  struct archive_entry *ae;
  struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

DEFINE_TEST(test_read_format_rar_multivolume_seek_data)
{
 const char *reffiles[] =
 {
 "test_rar_multivolume_single_file.part1.rar",
 "test_rar_multivolume_single_file.part2.rar",
 "test_rar_multivolume_single_file.part3.rar",
 NULL
 };
 char buff[64];
 int file_size = 20111;
 const char file_test_txt1[] = "d. \n\n"
 " \n\n</BODY>\n</HTML>";
 const char file_test_txt2[] = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4."
 "0 Transitional//EN\">\n<";
 const char file_test_txt3[] = "mplify writing such tests,\ntry to use plat"
 "form-independent codin";
 const char file_test_txt4[] = "lString</TT> in the example above)\ngenerat"
 "e detailed log message";
 const char file_test_txt5[] = "SS=\"western\">make check</TT> will usually"
 " run\n\tall of the tests.";
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Seek to the end minus 64 bytes */
  assertA(file_size - (int)sizeof(buff) ==
    archive_seek_data(a, file_size - (int)sizeof(buff), SEEK_SET));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);

/* Seek back to the beginning */
  assertA(0 == archive_seek_data(a, 0, SEEK_SET));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);

/* Seek to the middle of the combined data block */
  assertA(10054 == archive_seek_data(a, 10054, SEEK_SET));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);

/* Seek to 32 bytes before the end of the first data sub-block */
  assertA(6860 == archive_seek_data(a, 6860, SEEK_SET));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);

/* Seek to 32 bytes before the end of the second data sub-block */
  assertA(13752 == archive_seek_data(a, 13752, SEEK_SET));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);

/* Use various combinations of SEEK_SET, SEEK_CUR, and SEEK_END */
  assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
  assertEqualInt(0, archive_seek_data(a, 0, SEEK_SET));
  assertEqualInt(0, archive_seek_data(a, 0, SEEK_CUR));
  assertEqualInt(-1, archive_seek_data(a, -10, SEEK_CUR));
  assertEqualInt(10, archive_seek_data(a, 10, SEEK_CUR));
  assertEqualInt(-1, archive_seek_data(a, -20, SEEK_CUR));
  assertEqualInt(10, archive_seek_data(a, 0, SEEK_CUR));
  assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
  assertEqualInt(file_size - 20, archive_seek_data(a, -20, SEEK_END));
  assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_END));
  assertEqualInt(file_size + 40, archive_seek_data(a, 0, SEEK_CUR));
  assertEqualInt(file_size + 40 + 20, archive_seek_data(a, 20, SEEK_CUR));
  assertEqualInt(file_size + 40 + 20 + 20, archive_seek_data(a, 20, SEEK_CUR));
  assertEqualInt(file_size + 20, archive_seek_data(a, 20, SEEK_END));
  assertEqualInt(file_size - 20, archive_seek_data(a, -20, SEEK_END));

/*
   * Attempt to read from the end of the file. These should return
   * 0 for end of file.
   */
  assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
  assertA(0 == archive_read_data(a, buff, sizeof(buff)));
  assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
  assertA(0 == archive_read_data(a, buff, sizeof(buff)));

/* Seek to the end minus 64 bytes */
  assertA(0 == archive_seek_data(a, 0, SEEK_SET));
  assertA(file_size - (int)sizeof(buff) ==
    archive_seek_data(a, -(int)sizeof(buff), SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);

/* The file position should be at the end of the file here */
  assertA(file_size == archive_seek_data(a, 0, SEEK_CUR));

/* Seek back to the beginning */
  assertA(0 == archive_seek_data(a, -file_size, SEEK_CUR));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);

/* Seek to the middle of the combined data block */
  assertA(10054 == archive_seek_data(a, 10054 - (int)sizeof(buff), SEEK_CUR));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);

/* Seek to 32 bytes before the end of the first data sub-block */
  assertA(6860 == archive_seek_data(a, 6860 - (10054 + (int)sizeof(buff)),
                                    SEEK_CUR));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);

/* Seek to 32 bytes before the end of the second data sub-block */
  assertA(13752 == archive_seek_data(a, 13752 - file_size, SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);

DEFINE_TEST(test_read_format_rar_multivolume_seek_multiple_files)
{
 const char *reffiles[] =
 {
 "test_rar_multivolume_multiple_files.part1.rar",
 "test_rar_multivolume_multiple_files.part2.rar",
 "test_rar_multivolume_multiple_files.part3.rar",
 "test_rar_multivolume_multiple_files.part4.rar",
 "test_rar_multivolume_multiple_files.part5.rar",
 "test_rar_multivolume_multiple_files.part6.rar",
 NULL
 };
 char buff[64];
 int file_size = 20111;
 const char file_test_txt1[] = "d. \n\n"
 " \n\n</BODY>\n</HTML>";
 const char file_test_txt2[] = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4."
 "0 Transitional//EN\">\n<";
 const char file_test_txt3[] = "mplify writing such tests,\ntry to use plat"
 "form-independent codin";
 const char file_test_txt4[] = "\nfailures. \n\n<H1 CLASS=\"western\"><"
 "A NAME=\"Life_cycle_of_a_te";
 const char file_test_txt5[] = "LE=\"margin-bottom: 0in\">DO use runtime te"
 "sts for platform\n\tfeatu";
 const char file_test_txt6[] = "rough test suite is essential\nboth for ver"
 "ifying new ports and f";
 const char file_test_txt7[] = "m: 0in\">Creates a temporary directory\n\tw"
 "hose name matches the na";
 const char file_test_txt8[] = "lt\ninput file and verify the results. Thes"
 "e use <TT CLASS=\"weste";
 struct archive_entry *ae;
 struct archive *a;

/* First header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest2.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Attempt to read past end of file */
  assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
  assertA(0 == archive_read_data(a, buff, sizeof(buff)));
  assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
  assertA(0 == archive_read_data(a, buff, sizeof(buff)));

/* Seek to the end minus 64 bytes */
  assertA(file_size - (int)sizeof(buff) ==
    archive_seek_data(a, -(int)sizeof(buff), SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);

/* Seek back to the beginning */
  assertA(0 == archive_seek_data(a, -file_size, SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);

/* Seek to 32 bytes before the end of the first data sub-block */
  assertA(7027 == archive_seek_data(a, 7027 - (10054 + (int)sizeof(buff)),
                                    SEEK_CUR));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);

/* Seek to 32 bytes before the end of the second data sub-block */
  assertA(14086 == archive_seek_data(a, 14086 - file_size, SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);

/* Second header. */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(file_size, archive_entry_size(ae));
  assertEqualInt(33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Seek to 32 bytes before the end of the first data sub-block */
  assertA(969 == archive_seek_data(a, 969 - (10054 + (int)sizeof(buff)), SEEK_CUR));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt6, sizeof(file_test_txt4) - 1);

/* Seek to 32 bytes before the end of the second data sub-block */
  assertA(8029 == archive_seek_data(a, 8029 - file_size, SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt7, sizeof(file_test_txt5) - 1);

/* Seek to 32 bytes before the end of the third data sub-block */
  assertA(15089 == archive_seek_data(a, 15089 - file_size, SEEK_END));
  assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
  assertEqualMem(buff, file_test_txt8, sizeof(file_test_txt5) - 1);

static void
test_read_format_rar_multivolume_uncompressed_files_helper(struct archive *a)
{
  char buff[64];

/* Do checks for seeks/reads past beginning and end of file */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, -1, archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_SET));
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualIntA(a, (sizeof(buff)-1), archive_seek_data(a, 0, SEEK_CUR));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD "
 "HTML 4.0 Transitional//EN\">\n", buff);
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, -1, archive_seek_data(a, -(((int)sizeof(buff)-1)*2), SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1), archive_seek_data(a, 0, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualIntA(a, ((sizeof(buff)-1)*2), archive_seek_data(a, 0, SEEK_CUR));
 assertEqualStringA(a, "<HTML>\n<HEAD>\n\t<META HTTP-EQUIV=\"CONTENT-TYPE\" "
 "CONTENT=\"text/ht", buff);
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, -1, archive_seek_data(a, -(20111+32), SEEK_END));
 assertEqualIntA(a, ((sizeof(buff)-1)*2), archive_seek_data(a, 0, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualIntA(a, ((sizeof(buff)-1)*3), archive_seek_data(a, 0, SEEK_CUR));
 assertEqualStringA(a, "ml; charset=utf-8\">\n\t<TITLE></TITLE>\n\t<META "
 "NAME=\"GENERATOR\" CO", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 20111, archive_seek_data(a, 20111, SEEK_SET));
  assertEqualIntA(a, 20111, archive_seek_data(a, 0, SEEK_CUR));
  assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualIntA(a, 20111, archive_seek_data(a, 0, SEEK_CUR));
  assertEqualStringA(a, "", buff);
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 20111 + (sizeof(buff)-1),
    archive_seek_data(a, (sizeof(buff)-1), SEEK_CUR));
  assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualIntA(a, 20111 + (sizeof(buff)-1),
    archive_seek_data(a, 0, SEEK_CUR));
  assertEqualStringA(a, "", buff);
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 20111 + ((sizeof(buff)-1)*2),
    archive_seek_data(a, ((sizeof(buff)-1)*2), SEEK_END));
  assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualIntA(a, 20111 + ((sizeof(buff)-1)*2),
    archive_seek_data(a, 0, SEEK_CUR));
  assertEqualStringA(a, "", buff);
}

DEFINE_TEST(test_read_format_rar_multivolume_uncompressed_files)
{
  const char *reffiles[] =
  {
    "test_rar_multivolume_uncompressed_files.part01.rar",
    "test_rar_multivolume_uncompressed_files.part02.rar",
    "test_rar_multivolume_uncompressed_files.part03.rar",
    "test_rar_multivolume_uncompressed_files.part04.rar",
    "test_rar_multivolume_uncompressed_files.part05.rar",
    "test_rar_multivolume_uncompressed_files.part06.rar",
    "test_rar_multivolume_uncompressed_files.part07.rar",
    "test_rar_multivolume_uncompressed_files.part08.rar",
    "test_rar_multivolume_uncompressed_files.part09.rar",
    "test_rar_multivolume_uncompressed_files.part10.rar",
    NULL
  };
  char buff[64];
  ssize_t bytes_read;
  struct archive *a;
  struct archive_entry *ae;

extract_reference_files(reffiles);
  assert((a = archive_read_new()) != NULL);
  assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
  assertEqualIntA(a, ARCHIVE_OK,
                  archive_read_open_filenames(a, reffiles, 10240));

/*
   * First header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "testdir/LibarchiveAddingTest2.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Read from the beginning to the end of the file */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  do
  {
    memset(buff, 0, sizeof(buff));
    bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
  } while (bytes_read > 0);

/* Seek to the end minus (sizeof(buff)-1) bytes */
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

/* Seek back to the beginning */
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

/* Test that SEEK_SET works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, 13164, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, 0, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, 13164, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

/* Test that SEEK_CUR works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, 13164, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -13227, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 19985, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, -6947, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 6821, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -20111, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

/* Test that SEEK_END works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, -6947, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -20111, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13164,
    archive_seek_data(a, -6947, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equalit", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Second header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "testdir/testsubdir/LibarchiveAddingTest2.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Test that SEEK_SET works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, 6162, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 19347,
    archive_seek_data(a, 19347, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " when a block being written out by\n"
                        "the archive writer is the sa", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, 6162, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

/* Test that SEEK_CUR works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, 6162, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 19347,
    archive_seek_data(a, 13122, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " when a block being written out by\n"
                        "the archive writer is the sa", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 638, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 19347,
    archive_seek_data(a, -764, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " when a block being written out by\n"
                        "the archive writer is the sa", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, -13248, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -6225, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, -13949, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -19410, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 19347,
    archive_seek_data(a, 19284, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " when a block being written out by\n"
                        "the archive writer is the sa", buff);

/* Test that SEEK_END works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, -13949, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 19347,
    archive_seek_data(a, -764, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " when a block being written out by\n"
                        "the archive writer is the sa", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 6162,
    archive_seek_data(a, -13949, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "arguments satisfy certain conditions. "
                        "If the assertion fails--f", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Third header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "LibarchiveAddingTest2.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Test that SEEK_SET works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, 12353, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, 12353, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

/* Test that SEEK_CUR works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, 12353, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -12416, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, -7758, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 7632, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

/* Test that SEEK_END works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, -7758, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 12353,
    archive_seek_data(a, -7758, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
                        "extract_reference_file(&quot;test_foo.tar", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Fourth header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "testdir/LibarchiveAddingTest.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Test that SEEK_SET works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, 5371, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13165,
    archive_seek_data(a, 13165, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equality", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, 5371, SEEK_SET));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

/* Test that SEEK_CUR works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, 5371, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13165,
    archive_seek_data(a, 7731, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equality", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 6820, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13165,
    archive_seek_data(a, -6946, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equality", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, -7857, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -5434, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, -14740, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -13228, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13165,
    archive_seek_data(a, 13102, SEEK_CUR));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equality", buff);

/* Test that SEEK_END works correctly between data blocks */
  assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
  memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, -14740, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 13165,
    archive_seek_data(a, -6946, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
                        "assertEqualMem to test equality", buff);

memset(buff, 0, sizeof(buff));
  assertEqualIntA(a, 5371,
    archive_seek_data(a, -14740, SEEK_END));
  assertEqualIntA(a, (sizeof(buff)-1),
    archive_read_data(a, buff, (sizeof(buff)-1)));
  assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
                        "/* ... setup omitted ... */\n&nbsp; ", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Fifth header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "testdir/testsubdir/LibarchiveAddingTest.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Test that SEEK_SET works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, 11568, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, 11568, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

/* Test that SEEK_CUR works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, 11568, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -11631, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, -8543, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 8417, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

/* Test that SEEK_END works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, -8543, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 11568,
 archive_seek_data(a, -8543, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
 "\n\t<TT CLASS=\"west", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Sixth header.
   */
  assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  assertEqualStringA(a, "LibarchiveAddingTest.html",
                     archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualIntA(a, 20111, archive_entry_size(ae));
  assertEqualIntA(a, 33188, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/* Test that SEEK_SET works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, 4576, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 17749,
 archive_seek_data(a, 17749, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "\"></A>Large tar tester</H2>\nThe "
 "large tar tester attempts to", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, 4576, SEEK_SET));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

/* Test that SEEK_CUR works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, 4576, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 17749,
 archive_seek_data(a, 13110, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "\"></A>Large tar tester</H2>\nThe "
 "large tar tester attempts to", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
 archive_seek_data(a, 2236, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, ". \n\n \n"
 "\n</BODY>\n</HTML>", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 17749,
 archive_seek_data(a, -2362, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "\"></A>Large tar tester</H2>\nThe "
 "large tar tester attempts to", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, -13236, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -4639, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, -15535, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 0,
 archive_seek_data(a, -17812, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
 "Transitional//EN\">\n", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 17749,
 archive_seek_data(a, 17686, SEEK_CUR));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "\"></A>Large tar tester</H2>\nThe "
 "large tar tester attempts to", buff);

/* Test that SEEK_END works correctly between data blocks */
 assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
 memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, -15535, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 17749,
 archive_seek_data(a, -2362, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "\"></A>Large tar tester</H2>\nThe "
 "large tar tester attempts to", buff);

memset(buff, 0, sizeof(buff));
 assertEqualIntA(a, 4576,
 archive_seek_data(a, -15535, SEEK_END));
 assertEqualIntA(a, (sizeof(buff)-1),
 archive_read_data(a, buff, (sizeof(buff)-1)));
 assertEqualStringA(a, "hat was expected. \n\n<H1 CLASS=\"western\"><A "
 "NAME=\"Basic_test", buff);

test_read_format_rar_multivolume_uncompressed_files_helper(a);

/*
   * Seventh header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/testsymlink5", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testsubdir/LibarchiveAddingTest.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Eighth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/testsymlink6", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testsubdir/LibarchiveAddingTest2.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Ninth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testsymlink", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testdir/LibarchiveAddingTest.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Tenth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testsymlink2", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testdir/LibarchiveAddingTest2.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Eleventh header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testsymlink3", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testdir/testsubdir/LibarchiveAddingTest.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Twelfth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testsymlink4", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(41471, archive_entry_mode(ae));
  assertEqualString("testdir/testsubdir/LibarchiveAddingTest2.html",
    archive_entry_symlink(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));

/*
   * Thirteenth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/testemptysubdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/*
   * Fourteenth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir/testsubdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/*
   * Fifteenth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testdir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/*
   * Sixteenth header.
   */
  assertA(0 == archive_read_next_header(a, &ae));
  assertEqualString("testemptydir", archive_entry_pathname(ae));
  assertA((int)archive_entry_mtime(ae));
  assertA((int)archive_entry_ctime(ae));
  assertA((int)archive_entry_atime(ae));
  assertEqualInt(0, archive_entry_size(ae));
  assertEqualInt(16877, archive_entry_mode(ae));
  assertEqualInt(archive_entry_is_encrypted(ae), 0);
  assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);

/* Test EOF */
  assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
  assertEqualIntA(a, 16, archive_file_count(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_ppmd_use_after_free)
{
  uint8_t buf[16];
  const char* reffile = "test_read_format_rar_ppmd_use_after_free.rar";

struct archive_entry *ae;
  struct archive *a;

assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
 assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
 assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
 assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));

assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

DEFINE_TEST(test_read_format_rar_ppmd_use_after_free2)
{
  uint8_t buf[16];
  const char* reffile = "test_read_format_rar_ppmd_use_after_free2.rar";

struct archive_entry *ae;
  struct archive *a;

/* Test EOF */
  assertA(1 == archive_read_next_header(a, &ae));

assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}

003 File Manager

Editing: test_read_format_rar.c

Upload File

Create Folder