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) {
printf("Usage: minigzip [-x] [-d] [-0 to -9] [files]\n\n" \
" -x Extract file\n" \
" -d Destination directory\n" \
" -0 Store only\n" \
" -1 Compress faster\n" \
printf(
"Usage: minigzip [-x] [-d] [-0 to -9] [files]\n\n"
" -x Extract file\n"
" -d Destination directory\n"
" -0 Store only\n"
" -1 Compress faster\n"
" -9 Compress better\n\n");
return MZ_OK;
}

46
minizip.c
View File

@ -66,28 +66,30 @@ int32_t minizip_banner(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" \
" -x Extract files\n" \
" -l List files\n" \
" -d Destination directory\n" \
" -e Erase files\n" \
" -o Overwrite existing files\n" \
" -c File names use cp437 encoding (or specified codepage)\n" \
" -a Append to existing zip file\n" \
" -i Include full path of files\n" \
" -f Follow symbolic links\n" \
" -y Store symbolic links\n" \
" -v Verbose info\n" \
" -0 Store only\n" \
" -1 Compress faster\n" \
" -9 Compress better\n" \
" -k Disk size in KB\n" \
" -z Zip central directory\n" \
" -p Encryption password\n" \
" -s AES encryption\n" \
" -b BZIP2 compression\n" \
" -m LZMA compression\n" \
" -n XZ compression\n" \
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"
" -x Extract files\n"
" -l List files\n"
" -d Destination directory\n"
" -e Erase files\n"
" -o Overwrite existing files\n"
" -c File names use cp437 encoding (or specified codepage)\n"
" -a Append to existing zip file\n"
" -i Include full path of files\n"
" -f Follow symbolic links\n"
" -y Store symbolic links\n"
" -v Verbose info\n"
" -0 Store only\n"
" -1 Compress faster\n"
" -9 Compress better\n"
" -k Disk size in KB\n"
" -z Zip central directory\n"
" -p Encryption password\n"
" -s AES encryption\n"
" -b BZIP2 compression\n"
" -m LZMA compression\n"
" -n XZ compression\n"
" -t ZSTD compression\n\n");
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_NORMAL (0)
#define MZ_ZIP_FLAG_DEFLATE_FAST (1 << 2)
#define MZ_ZIP_FLAG_DEFLATE_SUPER_FAST (MZ_ZIP_FLAG_DEFLATE_FAST | \
MZ_ZIP_FLAG_DEFLATE_MAX)
#define MZ_ZIP_FLAG_DEFLATE_SUPER_FAST (MZ_ZIP_FLAG_DEFLATE_FAST | MZ_ZIP_FLAG_DEFLATE_MAX)
#define MZ_ZIP_FLAG_DATA_DESCRIPTOR (1 << 3)
#define MZ_ZIP_FLAG_UTF8 (1 << 11)
#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
/* 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
* purpose bit flag is set, it uses high byte of 16-bit File Time. */
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) {
/* 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),
MZ_ZIP_SIZE_MAX_DATA_DESCRIPTOR, &descriptor_pos);
if (err == MZ_OK) {
if (mz_zip_extrafield_contains(local_file_info.extrafield,
local_file_info.extrafield_size, MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK)
if (mz_zip_extrafield_contains(local_file_info.extrafield, local_file_info.extrafield_size,
MZ_ZIP_EXTENSION_ZIP64, NULL) == MZ_OK)
zip64 = 1;
err = mz_zip_entry_read_descriptor(zip->stream, zip64, &crc32,
&compressed_size, &uncompressed_size);
err =
mz_zip_entry_read_descriptor(zip->stream, zip64, &crc32, &compressed_size, &uncompressed_size);
if (err == MZ_OK) {
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))
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));
}

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_delete(&reader->hash);
err_hash = mz_zip_reader_entry_get_hash(handle, reader->hash_algorithm, expected_hash,
reader->hash_digest_size);
err_hash =
mz_zip_reader_entry_get_hash(handle, reader->hash_algorithm, expected_hash, reader->hash_digest_size);
if (err_hash == MZ_OK) {
/* 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) {
/* Set file attributes for the correct system */
err_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);
err_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)
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 (writer->raw)
err = mz_zip_entry_close_raw(writer->zip_handle, writer->file_info.uncompressed_size,
writer->file_info.crc);
err =
mz_zip_entry_close_raw(writer->zip_handle, writer->file_info.uncompressed_size, writer->file_info.crc);
else
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));
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",
Z_DEFLATED, level), ZIP_OK)
EXPECT_EQ(
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 << ")";
if (err != ZIP_OK)
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)
<< "failed to write to file in zip (err: " << err << ")";
EXPECT_EQ(err = zipCloseFileInZip(zip), ZIP_OK)
<< "failed to close file in zip (err: " << err << ")";
EXPECT_EQ(err = zipCloseFileInZip(zip), ZIP_OK) << "failed to close file in zip (err: " << err << ")";
}
TEST(compat, zip) {
@ -78,23 +78,17 @@ static void test_unzip_compat(unzFile unzip) {
EXPECT_STREQ(comment, "test global comment");
EXPECT_EQ(err = unzGetGlobalInfo(unzip, &global_info), UNZ_OK)
<< "global info (err: " << err << ")";
EXPECT_EQ(err = unzGetGlobalInfo(unzip, &global_info), UNZ_OK) << "global info (err: " << err << ")";
EXPECT_EQ(err = unzGetGlobalInfo64(unzip, &global_info64), UNZ_OK)
<< "global info l info 64-bit (err: " << err << ")";
EXPECT_EQ(global_info.number_entry, 2)
<< "invalid number of entries";
EXPECT_EQ(global_info64.number_entry, 2)
<< "invalid number of entries 64-bit";
EXPECT_EQ(global_info.number_entry, 2) << "invalid number of entries";
EXPECT_EQ(global_info64.number_entry, 2) << "invalid number of entries 64-bit";
EXPECT_EQ(global_info.number_disk_with_CD, 0)
<< "invalid disk with cd";
EXPECT_EQ(global_info64.number_disk_with_CD, 0)
<< "invalid disk with cd 64-bit";
EXPECT_EQ(global_info.number_disk_with_CD, 0) << "invalid disk with cd";
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)
<< "cannot locate test file (err: " << err << ")";
EXPECT_EQ(err = unzLocateFile(unzip, "test.txt", 1), UNZ_OK) << "cannot locate test file (err: " << err << ")";
EXPECT_EQ(err = unzGoToFirstFile(unzip), 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)
<< "failed to get current file info 64-bit (err: " << err << ")";
EXPECT_EQ(err = unzOpenCurrentFile(unzip), UNZ_OK)
<< "failed to open current file (err: " << err << ")";
EXPECT_EQ(err = unzOpenCurrentFile(unzip), UNZ_OK) << "failed to open current file (err: " << err << ")";
EXPECT_EQ(bytes_read = unzReadCurrentFile(unzip, buffer, sizeof(buffer)), (int32_t)strlen(test_data))
<< "failed to read zip entry data (err: " << err << ")";
EXPECT_EQ(unzEndOfFile(unzip), 1)
<< "end of zip not reported correctly";
EXPECT_EQ(unzEndOfFile(unzip), 1) << "end of zip not reported correctly";
EXPECT_EQ(err = unzCloseCurrentFile(unzip), UNZ_OK)
<< "failed to close current file (err: " << err << ")";
EXPECT_EQ(err = unzCloseCurrentFile(unzip), UNZ_OK) << "failed to close current file (err: " << err << ")";
EXPECT_EQ(unztell(unzip), bytes_read)
<< "unzip position not reported correctly";
EXPECT_EQ(unztell(unzip), bytes_read) << "unzip position not reported correctly";
EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_OK);
if (err != UNZ_OK)
return;
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 << ")";
EXPECT_STREQ(comment, "test local comment");
EXPECT_EQ(err = unzGetFilePos(unzip, &file_pos), UNZ_OK)
<< "unexpected file position (err: " << err << ")";
EXPECT_EQ(err = unzGetFilePos(unzip, &file_pos), UNZ_OK) << "unexpected file position (err: " << err << ")";
EXPECT_EQ(file_pos.num_of_file, 1)
<< "invalid file position";
EXPECT_EQ(file_pos.num_of_file, 1) << "invalid file position";
EXPECT_GT(unzGetOffset(unzip), 0)
<< "invalid offset";
EXPECT_GT(unzGetOffset(unzip), 0) << "invalid offset";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_OK)
<< "cannot seek to beginning (err: " << err << ")";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_OK) << "cannot seek to beginning (err: " << err << ")";
EXPECT_EQ(err = unzGoToNextFile(unzip), UNZ_END_OF_LIST_OF_FILE)
<< "failed to reach end of list of files (err: " << err << ")";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_PARAMERROR)
<< "cannot seek to beginning (err: " << err << ")";
EXPECT_EQ(err = unzSeek64(unzip, 0, SEEK_SET), UNZ_PARAMERROR) << "cannot seek to beginning (err: " << err << ")";
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) {
int fseek_origin = 0;
long ret = 0;
switch (origin)
{
switch (origin) {
case ZLIB_FILEFUNC_SEEK_CUR:
fseek_origin = SEEK_CUR;
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) {
int fseek_origin = 0;
long ret = 0;
switch (origin)
{
switch (origin) {
case ZLIB_FILEFUNC_SEEK_CUR:
fseek_origin = SEEK_CUR;
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));
EXPECT_STREQ(computed_hash, "e1e42e5977965bb3621231a5df3a1e83c471fa91fde33b6a30c8c4fa0d8be29ba7171c7c9487db91e9ee7e85049f7b41");
EXPECT_STREQ(computed_hash,
"e1e42e5977965bb3621231a5df3a1e83c471fa91fde33b6a30c8c4fa0d8be29ba7171c7c9487db91e9ee7e85049f7b41");
# endif
}
@ -159,7 +160,9 @@ TEST(crypt, sha512) {
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
}
@ -228,7 +231,6 @@ TEST(crypt, aes128_cbc) {
EXPECT_STREQ((char *)buf, test);
}
TEST(crypt, aes128_gcm) {
# if GTEST_OS_WINDOWS && _WIN32_WINNT <= _WIN32_WINNT_XP
GTEST_SKIP() << "SHA256 not supported on Windows XP";
@ -412,8 +414,9 @@ TEST(crypt, pbkdf2) {
const char *password = "passwordpasswordpasswordpassword";
const char *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "8F3472E4EA57F56E36F30246DC22C173";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "salt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password),
(uint8_t *)salt, (int32_t)strlen(salt), iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, (int32_t)strlen(password), (uint8_t *)salt, (int32_t)strlen(salt),
iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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 *salt = "sa\0lt";
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, 9,
(uint8_t *)salt, 5, iteration_count, key, (uint16_t)sizeof(key)), MZ_OK);
EXPECT_EQ(mz_crypt_pbkdf2((uint8_t *)password, 9, (uint8_t *)salt, 5, iteration_count, key, (uint16_t)sizeof(key)),
MZ_OK);
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"},
};
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));

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
was written to stream */
EXPECT_EQ(position, (i < find_size) ? -1 : 0)
<< "name: " << name << std::endl
EXPECT_EQ(position, (i < find_size) ? -1 : 0) << "name: " << name << std::endl
<< "find_size: " << find_size << 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
was written to stream */
EXPECT_EQ(position, (i < find_size) ? -1 : (i - find_size))
<< "name: " << name << std::endl
EXPECT_EQ(position, (i < find_size) ? -1 : (i - find_size)) << "name: " << name << std::endl
<< "find_size: " << find_size << 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);
/* Should always find after initial set of zeros */
EXPECT_EQ(position, i)
<< "name: " << name << std::endl
EXPECT_EQ(position, i) << "name: " << name << std::endl
<< "find_size: " << find_size << 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);
/* Should always find after initial set of zeros */
EXPECT_EQ(position, i)
<< "name: " << name << std::endl
EXPECT_EQ(position, i) << "name: " << name << std::endl
<< "find_size: " << find_size << 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}
};
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));