c/minizip-ng
1
0
Fork 0
mirror of https://github.com/zlib-ng/minizip-ng synced 2025-03-28 21:13:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Apply Clang format

Browse Source
This commit is contained in:
tbeu 2025-02-18 23:01:11 +01:00 committed by Nathan Moinvaziri
parent 5e99d52a00
commit 1529686f37
10 changed files with 347 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
minigzip.c
View File

@ -33,11 +33,12 @@ int32_t minigzip_banner(void) {
} }
int32_t minigzip_help(void) { int32_t minigzip_help(void) {
printf("Usage: minigzip [-x] [-d] [-0 to -9] [files]\n\n" \ printf(
" -x Extract file\n" \ "Usage: minigzip [-x] [-d] [-0 to -9] [files]\n\n"
" -d Destination directory\n" \ " -x Extract file\n"
" -0 Store only\n" \ " -d Destination directory\n"
" -1 Compress faster\n" \ " -0 Store only\n"
" -1 Compress faster\n"
" -9 Compress better\n\n"); " -9 Compress better\n\n");
return MZ_OK; return MZ_OK;
} }

46
minizip.c
View File

@ -66,28 +66,30 @@ int32_t minizip_banner(void) {
} }
int32_t minizip_help(void) { int32_t minizip_help(void) {
printf("Usage: minizip [-x][-d dir|-l|-e][-o][-f][-y][-c cp][-a][-0 to -9][-b|-m|-t][-k 512][-p pwd][-s] file.zip [files]\n\n" \ printf(
" -x Extract files\n" \ "Usage: minizip [-x][-d dir|-l|-e][-o][-f][-y][-c cp][-a][-0 to -9][-b|-m|-t][-k 512][-p pwd][-s] file.zip "
" -l List files\n" \ "[files]\n\n"
" -d Destination directory\n" \ " -x Extract files\n"
" -e Erase files\n" \ " -l List files\n"
" -o Overwrite existing files\n" \ " -d Destination directory\n"
" -c File names use cp437 encoding (or specified codepage)\n" \ " -e Erase files\n"
" -a Append to existing zip file\n" \ " -o Overwrite existing files\n"
" -i Include full path of files\n" \ " -c File names use cp437 encoding (or specified codepage)\n"
" -f Follow symbolic links\n" \ " -a Append to existing zip file\n"
" -y Store symbolic links\n" \ " -i Include full path of files\n"
" -v Verbose info\n" \ " -f Follow symbolic links\n"
" -0 Store only\n" \ " -y Store symbolic links\n"
" -1 Compress faster\n" \ " -v Verbose info\n"
" -9 Compress better\n" \ " -0 Store only\n"
" -k Disk size in KB\n" \ " -1 Compress faster\n"
" -z Zip central directory\n" \ " -9 Compress better\n"
" -p Encryption password\n" \ " -k Disk size in KB\n"
" -s AES encryption\n" \ " -z Zip central directory\n"
" -b BZIP2 compression\n" \ " -p Encryption password\n"
" -m LZMA compression\n" \ " -s AES encryption\n"
" -n XZ compression\n" \ " -b BZIP2 compression\n"
" -m LZMA compression\n"
" -n XZ compression\n"
" -t ZSTD compression\n\n"); " -t ZSTD compression\n\n");
return MZ_OK; return MZ_OK;
} }

3
mz.h
View File

@ -79,8 +79,7 @@
#define MZ_ZIP_FLAG_DEFLATE_MAX (1 << 1) #define MZ_ZIP_FLAG_DEFLATE_MAX (1 << 1)
#define MZ_ZIP_FLAG_DEFLATE_NORMAL (0) #define MZ_ZIP_FLAG_DEFLATE_NORMAL (0)
#define MZ_ZIP_FLAG_DEFLATE_FAST (1 << 2) #define MZ_ZIP_FLAG_DEFLATE_FAST (1 << 2)
#define MZ_ZIP_FLAG_DEFLATE_SUPER_FAST (MZ_ZIP_FLAG_DEFLATE_FAST | \ #define MZ_ZIP_FLAG_DEFLATE_SUPER_FAST (MZ_ZIP_FLAG_DEFLATE_FAST | MZ_ZIP_FLAG_DEFLATE_MAX)
MZ_ZIP_FLAG_DEFLATE_MAX)
#define MZ_ZIP_FLAG_DATA_DESCRIPTOR (1 << 3) #define MZ_ZIP_FLAG_DATA_DESCRIPTOR (1 << 3)
#define MZ_ZIP_FLAG_UTF8 (1 << 11) #define MZ_ZIP_FLAG_UTF8 (1 << 11)
#define MZ_ZIP_FLAG_MASK_LOCAL_INFO (1 << 13) #define MZ_ZIP_FLAG_MASK_LOCAL_INFO (1 << 13)

17
mz_zip.c
View File

@ -188,8 +188,7 @@ static int32_t mz_zip_search_zip64_eocd(void *stream, const int64_t end_central_
#ifdef HAVE_PKCRYPT #ifdef HAVE_PKCRYPT
/* Get PKWARE traditional encryption verifier */ /* Get PKWARE traditional encryption verifier */
static uint16_t mz_zip_get_pk_verify(uint32_t dos_date, uint64_t crc, uint16_t flag) static uint16_t mz_zip_get_pk_verify(uint32_t dos_date, uint64_t crc, uint16_t flag) {
{
/* Info-ZIP modification to ZipCrypto format: if bit 3 of the general /* Info-ZIP modification to ZipCrypto format: if bit 3 of the general
* purpose bit flag is set, it uses high byte of 16-bit File Time. */ * purpose bit flag is set, it uses high byte of 16-bit File Time. */
if (flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR) if (flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR)
@ -1326,16 +1325,17 @@ static int32_t mz_zip_recover_cd(void *handle) {
} }
if (local_file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR || local_file_info.compressed_size == 0) { if (local_file_info.flag & MZ_ZIP_FLAG_DATA_DESCRIPTOR || local_file_info.compressed_size == 0) {
/* Search backwards for the descriptor, seeking too far back will be incorrect if compressed size is small */ /* Search backwards for the descriptor, seeking too far back will be incorrect if compressed size is
* small */
err = mz_stream_find_reverse(zip->stream, (const void *)descriptor_magic, sizeof(descriptor_magic), err = mz_stream_find_reverse(zip->stream, (const void *)descriptor_magic, sizeof(descriptor_magic),
MZ_ZIP_SIZE_MAX_DATA_DESCRIPTOR, &descriptor_pos); MZ_ZIP_SIZE_MAX_DATA_DESCRIPTOR, &descriptor_pos);
if (err == MZ_OK) { if (err == MZ_OK) {
if (mz_zip_extrafield_contains(local_file_info.extrafield, if (mz_zip_extrafield_contains(local_file_info.extrafield, local_file_info.extrafield_size,
local_file_info.extrafield_size, MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK) MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK)
zip64 = 1; zip64 = 1;
err = mz_zip_entry_read_descriptor(zip->stream, zip64, &crc32, err =
&compressed_size, &uncompressed_size); mz_zip_entry_read_descriptor(zip->stream, zip64, &crc32, &compressed_size, &uncompressed_size);
if (err == MZ_OK) { if (err == MZ_OK) {
if (local_file_info.crc == 0) if (local_file_info.crc == 0)
@ -2734,7 +2734,8 @@ uint32_t mz_zip_tm_to_dosdate(const struct tm *ptm) {
if (mz_zip_invalid_date(&fixed_tm)) if (mz_zip_invalid_date(&fixed_tm))
return 0; return 0;
return (((uint32_t)fixed_tm.tm_mday + (32 * ((uint32_t)fixed_tm.tm_mon + 1)) + (512 * (uint32_t)fixed_tm.tm_year)) << 16) | return (((uint32_t)fixed_tm.tm_mday + (32 * ((uint32_t)fixed_tm.tm_mon + 1)) + (512 * (uint32_t)fixed_tm.tm_year))
<< 16) |
(((uint32_t)fixed_tm.tm_sec / 2) + (32 * (uint32_t)fixed_tm.tm_min) + (2048 * (uint32_t)fixed_tm.tm_hour)); (((uint32_t)fixed_tm.tm_sec / 2) + (32 * (uint32_t)fixed_tm.tm_min) + (2048 * (uint32_t)fixed_tm.tm_hour));
} }

13
mz_zip_rw.c
View File

@ -435,8 +435,8 @@ int32_t mz_zip_reader_entry_close(void *handle) {
mz_crypt_sha_end(reader->hash, computed_hash, sizeof(computed_hash)); mz_crypt_sha_end(reader->hash, computed_hash, sizeof(computed_hash));
mz_crypt_sha_delete(&reader->hash); mz_crypt_sha_delete(&reader->hash);
err_hash = mz_zip_reader_entry_get_hash(handle, reader->hash_algorithm, expected_hash, err_hash =
reader->hash_digest_size); mz_zip_reader_entry_get_hash(handle, reader->hash_algorithm, expected_hash, reader->hash_digest_size);
if (err_hash == MZ_OK) { if (err_hash == MZ_OK) {
/* Verify expected hash against computed hash */ /* Verify expected hash against computed hash */
@ -754,8 +754,9 @@ int32_t mz_zip_reader_entry_save_file(void *handle, const char *path) {
if (err == MZ_OK) { if (err == MZ_OK) {
/* Set file attributes for the correct system */ /* Set file attributes for the correct system */
err_attrib = mz_zip_attrib_convert(MZ_HOST_SYSTEM(reader->file_info->version_madeby), err_attrib =
reader->file_info->external_fa, MZ_VERSION_MADEBY_HOST_SYSTEM, &target_attrib); mz_zip_attrib_convert(MZ_HOST_SYSTEM(reader->file_info->version_madeby), reader->file_info->external_fa,
MZ_VERSION_MADEBY_HOST_SYSTEM, &target_attrib);
if (err_attrib == MZ_OK) if (err_attrib == MZ_OK)
mz_os_set_file_attribs(pathwfs, target_attrib); mz_os_set_file_attribs(pathwfs, target_attrib);
@ -1400,8 +1401,8 @@ int32_t mz_zip_writer_entry_close(void *handle) {
if (err == MZ_OK) { if (err == MZ_OK) {
if (writer->raw) if (writer->raw)
err = mz_zip_entry_close_raw(writer->zip_handle, writer->file_info.uncompressed_size, err =
writer->file_info.crc); mz_zip_entry_close_raw(writer->zip_handle, writer->file_info.uncompressed_size, writer->file_info.crc);
else else
err = mz_zip_entry_close(writer->zip_handle); err = mz_zip_entry_close(writer->zip_handle);
} }

63
test/test_compat.cc
View File

@ -27,8 +27,9 @@ static void test_zip_compat(zipFile zip, const char *filename, int32_t level) {
memset(&file_info, 0, sizeof(file_info)); memset(&file_info, 0, sizeof(file_info));
file_info.dosDate = mz_zip_time_t_to_dos_date(1588561637); file_info.dosDate = mz_zip_time_t_to_dos_date(1588561637);
EXPECT_EQ(err = zipOpenNewFileInZip(zip, filename, &file_info, NULL, 0, NULL, 0, "test local comment", EXPECT_EQ(
Z_DEFLATED, level), ZIP_OK) err = zipOpenNewFileInZip(zip, filename, &file_info, NULL, 0, NULL, 0, "test local comment", Z_DEFLATED, level),
ZIP_OK)
<< "failed to open new file in zip (err: " << err << ")"; << "failed to open new file in zip (err: " << err << ")";
if (err != ZIP_OK) if (err != ZIP_OK)
return; return;
@ -36,8 +37,7 @@ static void test_zip_compat(zipFile zip, const char *filename, int32_t level) {
EXPECT_EQ(err = zipWriteInFileInZip(zip, buffer, (uint32_t)strlen(buffer)), ZIP_OK) EXPECT_EQ(err = zipWriteInFileInZip(zip, buffer, (uint32_t)strlen(buffer)), ZIP_OK)
<< "failed to write to file in zip (err: " << err << ")"; << "failed to write to file in zip (err: " << err << ")";
EXPECT_EQ(err = zipCloseFileInZip(zip), ZIP_OK) EXPECT_EQ(err = zipCloseFileInZip(zip), ZIP_OK) << "failed to close file in zip (err: " << err << ")";
<< "failed to close file in zip (err: " << err << ")";
} }
TEST(compat, zip) { TEST(compat, zip) {
@ -78,23 +78,17 @@ static void test_unzip_compat(unzFile unzip) {
EXPECT_STREQ(comment, "test global comment"); EXPECT_STREQ(comment, "test global comment");
EXPECT_EQ(err = unzGetGlobalInfo(unzip, &global_info), UNZ_OK) EXPECT_EQ(err = unzGetGlobalInfo(unzip, &global_info), UNZ_OK) << "global info (err: " << err << ")";
<< "global info (err: " << err << ")";
EXPECT_EQ(err = unzGetGlobalInfo64(unzip, &global_info64), UNZ_OK) EXPECT_EQ(err = unzGetGlobalInfo64(unzip, &global_info64), UNZ_OK)
<< "global info l info 64-bit (err: " << err << ")"; << "global info l info 64-bit (err: " << err << ")";
EXPECT_EQ(global_info.number_entry, 2) EXPECT_EQ(global_info.number_entry, 2) << "invalid number of entries";
<< "invalid number of entries"; EXPECT_EQ(global_info64.number_entry, 2) << "invalid number of entries 64-bit";
EXPECT_EQ(global_info64.number_entry, 2)
<< "invalid number of entries 64-bit";
EXPECT_EQ(global_info.number_disk_with_CD, 0) EXPECT_EQ(global_info.number_disk_with_CD, 0) << "invalid disk with cd";
<< "invalid disk with cd"; EXPECT_EQ(global_info64.number_disk_with_CD, 0) << "invalid disk with cd 64-bit";
EXPECT_EQ(global_info64.number_disk_with_CD, 0)
<< "invalid disk with cd 64-bit";
EXPECT_EQ(err = unzLocateFile(unzip, "test.txt", 1), UNZ_OK) EXPECT_EQ(err = unzLocateFile(unzip, "test.txt", 1), UNZ_OK) << "cannot locate test file (err: " << err << ")";
<< "cannot locate test file (err: " << err << ")";
EXPECT_EQ(err = unzGoToFirstFile(unzip), UNZ_OK); EXPECT_EQ(err = unzGoToFirstFile(unzip), UNZ_OK);
if (err != UNZ_OK) if (err != UNZ_OK)
@ -102,48 +96,41 @@ static void test_unzip_compat(unzFile unzip) {
EXPECT_EQ(err = unzGetCurrentFileInfo64(unzip, &file_info64, filename, sizeof(filename), NULL, 0, NULL, 0), UNZ_OK) EXPECT_EQ(err = unzGetCurrentFileInfo64(unzip, &file_info64, filename, sizeof(filename), NULL, 0, NULL, 0), UNZ_OK)
<< "failed to get current file info 64-bit (err: " << err << ")"; << "failed to get current file info 64-bit (err: " << err << ")";
EXPECT_EQ(err = unzOpenCurrentFile(unzip), UNZ_OK) EXPECT_EQ(err = unzOpenCurrentFile(unzip), UNZ_OK) << "failed to open current file (err: " << err << ")";
<< "failed to open current file (err: " << err << ")";
EXPECT_EQ(bytes_read = unzReadCurrentFile(unzip, buffer, sizeof(buffer)), (int32_t)strlen(test_data)) EXPECT_EQ(bytes_read = unzReadCurrentFile(unzip, buffer, sizeof(buffer)), (int32_t)strlen(test_data))
<< "failed to read zip entry data (err: " << err << ")"; << "failed to read zip entry data (err: " << err << ")";
EXPECT_EQ(unzEndOfFile(unzip), 1) EXPECT_EQ(unzEndOfFile(unzip), 1) << "end of zip not reported correctly";
<< "end of zip not reported correctly";
EXPECT_EQ(err = unzCloseCurrentFile(unzip), UNZ_OK) EXPECT_EQ(err = unzCloseCurrentFile(unzip), UNZ_OK) << "failed to close current file (err: " << err << ")";
<< "failed to close current file (err: " << err << ")";
EXPECT_EQ(unztell(unzip), bytes_read) EXPECT_EQ(unztell(unzip), bytes_read) << "unzip position not reported correctly";
<< "unzip position not reported correctly";
EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_OK); EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_OK);
if (err != UNZ_OK) if (err != UNZ_OK)
return; return;
comment[0] = 0; comment[0] = 0;
EXPECT_EQ(err = unzGetCurrentFileInfo(unzip, &file_info, filename, sizeof(filename), NULL, 0, comment, sizeof(comment)), UNZ_OK) EXPECT_EQ(
err = unzGetCurrentFileInfo(unzip, &file_info, filename, sizeof(filename), NULL, 0, comment, sizeof(comment)),
UNZ_OK)
<< "failed to get current file info (err: " << err << ")"; << "failed to get current file info (err: " << err << ")";
EXPECT_STREQ(comment, "test local comment"); EXPECT_STREQ(comment, "test local comment");
EXPECT_EQ(err = unzGetFilePos(unzip, &file_pos), UNZ_OK) EXPECT_EQ(err = unzGetFilePos(unzip, &file_pos), UNZ_OK) << "unexpected file position (err: " << err << ")";
<< "unexpected file position (err: " << err << ")";
EXPECT_EQ(file_pos.num_of_file, 1) EXPECT_EQ(file_pos.num_of_file, 1) << "invalid file position";
<< "invalid file position";
EXPECT_GT(unzGetOffset(unzip), 0) EXPECT_GT(unzGetOffset(unzip), 0) << "invalid offset";
<< "invalid offset";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_OK) EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_OK) << "cannot seek to beginning (err: " << err << ")";
<< "cannot seek to beginning (err: " << err << ")";
EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_END_OF_LIST_OF_FILE) EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_END_OF_LIST_OF_FILE)
<< "failed to reach end of list of files (err: " << err << ")"; << "failed to reach end of list of files (err: " << err << ")";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_PARAMERROR) EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_PARAMERROR) << "cannot seek to beginning (err: " << err << ")";
<< "cannot seek to beginning (err: " << err << ")";
unzCloseCurrentFile(unzip); unzCloseCurrentFile(unzip);
} }
@ -200,8 +187,7 @@ static ZPOS64_T ZCALLBACK ftell64_file_func(void *opaque, void *stream) {
static long ZCALLBACK fseek_file_func(void *opaque, void *stream, unsigned long offset, int origin) { static long ZCALLBACK fseek_file_func(void *opaque, void *stream, unsigned long offset, int origin) {
int fseek_origin = 0; int fseek_origin = 0;
long ret = 0; long ret = 0;
switch (origin) switch (origin) {
{
case ZLIB_FILEFUNC_SEEK_CUR: case ZLIB_FILEFUNC_SEEK_CUR:
fseek_origin = SEEK_CUR; fseek_origin = SEEK_CUR;
break; break;
@ -222,8 +208,7 @@ static long ZCALLBACK fseek_file_func(void *opaque, void *stream, unsigned long
static long ZCALLBACK fseek64_file_func(void *opaque, void *stream, ZPOS64_T offset, int origin) { static long ZCALLBACK fseek64_file_func(void *opaque, void *stream, ZPOS64_T offset, int origin) {
int fseek_origin = 0; int fseek_origin = 0;
long ret = 0; long ret = 0;
switch (origin) switch (origin) {
{
case ZLIB_FILEFUNC_SEEK_CUR: case ZLIB_FILEFUNC_SEEK_CUR:
fseek_origin = SEEK_CUR; fseek_origin = SEEK_CUR;
break; break;

47
test/test_crypt.cc
View File

@ -135,7 +135,8 @@ TEST(crypt, sha384) {
convert_buffer_to_hex_string(hash384, sizeof(hash384), computed_hash, sizeof(computed_hash)); convert_buffer_to_hex_string(hash384, sizeof(hash384), computed_hash, sizeof(computed_hash));
EXPECT_STREQ(computed_hash, "e1e42e5977965bb3621231a5df3a1e83c471fa91fde33b6a30c8c4fa0d8be29ba7171c7c9487db91e9ee7e85049f7b41"); EXPECT_STREQ(computed_hash,
"e1e42e5977965bb3621231a5df3a1e83c471fa91fde33b6a30c8c4fa0d8be29ba7171c7c9487db91e9ee7e85049f7b41");
# endif # endif
} }
@ -159,7 +160,9 @@ TEST(crypt, sha512) {
convert_buffer_to_hex_string(hash512, sizeof(hash512), computed_hash, sizeof(computed_hash)); convert_buffer_to_hex_string(hash512, sizeof(hash512), computed_hash, sizeof(computed_hash));
EXPECT_STREQ(computed_hash, "6627e7643ee7ce633e03f52d22329c3a32597364247c5275d4369985e1518626da46f595ad327667346479d246359b8b381af791ce2ac8c53a4788050eea11fe"); EXPECT_STREQ(computed_hash,
"6627e7643ee7ce633e03f52d22329c3a32597364247c5275d4369985e1518626da46f595ad327667346479d246359b8b381af"
"791ce2ac8c53a4788050eea11fe");
# endif # endif
} }
@ -228,7 +231,6 @@ TEST(crypt, aes128_cbc) {
EXPECT_STREQ((char *)buf, test); EXPECT_STREQ((char *)buf, test);
} }
TEST(crypt, aes128_gcm) { TEST(crypt, aes128_gcm) {
# if GTEST_OS_WINDOWS && _WIN32_WINNT <= _WIN32_WINNT_XP # if GTEST_OS_WINDOWS && _WIN32_WINNT <= _WIN32_WINNT_XP
GTEST_SKIP() << "SHA256 not supported on Windows XP"; GTEST_SKIP() << "SHA256 not supported on Windows XP";
@ -412,8 +414,9 @@ TEST(crypt, pbkdf2) {
const char *password = "passwordpasswordpasswordpassword"; const char *password = "passwordpasswordpasswordpassword";
const char *salt = "8F3472E4EA57F56E36F30246DC22C173"; const char *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -428,8 +431,9 @@ TEST(crypt, pbkdf2_long_odd_password) {
const char *password = "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordp"; const char *password = "passwordpasswordpasswordpasswordpasswordpasswordpasswordpasswordp";
const char *salt = "8F3472E4EA57F56E36F30246DC22C173"; const char *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -444,8 +448,9 @@ TEST(crypt, pbkdf2_short_password) {
const char *password = "p"; const char *password = "p";
const char *salt = "8F3472E4EA57F56E36F30246DC22C173"; const char *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -460,8 +465,9 @@ TEST(crypt, pbkdf2_rfc6070_v1) {
const char *password = "password"; const char *password = "password";
const char *salt = "salt"; const char *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -476,8 +482,9 @@ TEST(crypt, pbkdf2_rfc6070_v2) {
const char *password = "password"; const char *password = "password";
const char *salt = "salt"; const char *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -492,8 +499,9 @@ TEST(crypt, pbkdf2_rfc6070_v3) {
const char *password = "password"; const char *password = "password";
const char *salt = "salt"; const char *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -508,8 +516,9 @@ TEST(crypt, pbkdf2_rfc6070_v4) {
const char *password = "passwordPASSWORDpassword"; const char *password = "passwordPASSWORDpassword";
const char *salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt"; const char *salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));
@ -524,8 +533,8 @@ TEST(crypt, pbkdf2_rfc6070_v5) {
const char *password = "pass\0word"; const char *password = "pass\0word";
const char *salt = "sa\0lt"; const char *salt = "sa\0lt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, 9, EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, 9, (uint8_t *)salt, 5, iteration_count, key, (uint16_t)sizeof(key)),
(uint8_t *)salt, 5, iteration_count, key, (uint16_t)sizeof(key)), MZ_OK); MZ_OK);
convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex)); convert_buffer_to_hex_string(key, sizeof(key), key_hex, sizeof(key_hex));

4
test/test_path.cc
View File

@ -45,9 +45,7 @@ constexpr resolve_path_param resolve_path_tests[] = {
{ "c:\\test\\123\\..\\.\\..\\abc.txt", "c:\\abc.txt"}, { "c:\\test\\123\\..\\.\\..\\abc.txt", "c:\\abc.txt"},
}; };
class path_resolve : public ::testing::TestWithParam<resolve_path_param> { class path_resolve : public ::testing::TestWithParam<resolve_path_param> {};
};
INSTANTIATE_TEST_SUITE_P(os, path_resolve, testing::ValuesIn(resolve_path_tests)); INSTANTIATE_TEST_SUITE_P(os, path_resolve, testing::ValuesIn(resolve_path_tests));

16
test/test_stream.cc
View File

@ -49,8 +49,7 @@ static void test_stream_find_begin(const char *name, int32_t count, const uint8_
/* Should always find at the start of the stream if entire needle /* Should always find at the start of the stream if entire needle
was written to stream */ was written to stream */
EXPECT_EQ(position, (i < find_size) ? -1 : 0) EXPECT_EQ(position, (i < find_size) ? -1 : 0) << "name: " << name << std::endl
<< "name: " << name << std::endl
<< "find_size: " << find_size << std::endl << "find_size: " << find_size << std::endl
<< "index: " << i << std::endl; << "index: " << i << std::endl;
@ -96,8 +95,7 @@ static void test_stream_find_end(const char *name, int32_t count, const uint8_t
/* Should always find after zeros if entire needle /* Should always find after zeros if entire needle
was written to stream */ was written to stream */
EXPECT_EQ(position, (i < find_size) ? -1 : (i - find_size)) EXPECT_EQ(position, (i < find_size) ? -1 : (i - find_size)) << "name: " << name << std::endl
<< "name: " << name << std::endl
<< "find_size: " << find_size << std::endl << "find_size: " << find_size << std::endl
<< "index: " << i << std::endl; << "index: " << i << std::endl;
@ -142,8 +140,7 @@ static void test_stream_find_middle(const char *name, int32_t count, const uint8
find_cb(mem_stream, (const void *)find, find_size, i + find_size + i, &position); find_cb(mem_stream, (const void *)find, find_size, i + find_size + i, &position);
/* Should always find after initial set of zeros */ /* Should always find after initial set of zeros */
EXPECT_EQ(position, i) EXPECT_EQ(position, i) << "name: " << name << std::endl
<< "name: " << name << std::endl
<< "find_size: " << find_size << std::endl << "find_size: " << find_size << std::endl
<< "index: " << i << std::endl; << "index: " << i << std::endl;
@ -188,8 +185,7 @@ static void test_stream_find_middle_odd(const char *name, int32_t count, const u
find_cb(mem_stream, (const void *)find, find_size, i + find_size + i + 1, &position); find_cb(mem_stream, (const void *)find, find_size, i + find_size + i + 1, &position);
/* Should always find after initial set of zeros */ /* Should always find after initial set of zeros */
EXPECT_EQ(position, i) EXPECT_EQ(position, i) << "name: " << name << std::endl
<< "name: " << name << std::endl
<< "find_size: " << find_size << std::endl << "find_size: " << find_size << std::endl
<< "index: " << i << std::endl; << "index: " << i << std::endl;
@ -223,9 +219,7 @@ constexpr stream_find_param find_tests[] = {
{"middle odd reverse", test_stream_find_middle_odd, mz_stream_find_reverse} {"middle odd reverse", test_stream_find_middle_odd, mz_stream_find_reverse}
}; };
class stream_find : public ::testing::TestWithParam<stream_find_param> { class stream_find : public ::testing::TestWithParam<stream_find_param> {};
};
INSTANTIATE_TEST_SUITE_P(stream, stream_find, testing::ValuesIn(find_tests)); INSTANTIATE_TEST_SUITE_P(stream, stream_find, testing::ValuesIn(find_tests));