test: round-trip decompressZip check in CompressManySmallFilesToZip (#5958)

* test: round-trip decompressZip check in CompressManySmallFilesToZip

After compressing the generated 20 .bin + 20 .json source files to
many.zip, also decompress the archive into a fresh temp folder and
verify every original file is recovered byte-for-byte. The existing
size-envelope check only proves the zip is present and not pathological;
a byte-level round-trip compare catches the kinds of regressions that
have shown up on this path before (wrong compression method byte on an
entry, CRC-vs-data mismatch, off-by-one in a local file header, entry
truncation) and would otherwise require a real reader -- 7-Zip / Python
zipfile -- to detect.

The loop walks srcFolder recursively, mirrors each regular file's
relative path into the decompressed tree, asserts presence and size
parity, then byte-compares content. The final EXPECT confirms all
numBinaryFiles + numJsonFiles entries (default 40) were actually seen.

No changes to the sphere test -- it checks a single .mrmesh file that
MeshLib's own loader already round-trips in other tests.

* test: iterate with DirectoryRecursive instead of std::filesystem iterator

Match the style already used in MRZip.cpp. Unlike the std library's
recursive_directory_iterator, MRMesh's DirectoryRecursive accepts an
error_code at construction and saves errors into it rather than
throwing, so the loop cannot raise std::filesystem_error on a
transient permission glitch, a removed file, etc.

No behavioural change for the happy path; same iteration order, same
directory_entry values, same is_regular_file / relative calls.

Author: Fedr

source/MRTest/MRZipCompressTests.cpp

@@ -1,3 +1,4 @@
+#include <MRMesh/MRDirectory.h>
 #include <MRMesh/MRGTest.h>
 #include <MRMesh/MRMakeSphereMesh.h>
 #include <MRMesh/MRMesh.h>
@@ -194,6 +195,50 @@ TEST( MRMesh, CompressManySmallFilesToZip )
 
     // Sanity envelope: same bound as the sphere test.
     EXPECT_LT( zipSize, totalInput * 2u );
+
+    // Round-trip: decompress the archive into a fresh temp folder and verify
+    // every original file comes back byte-for-byte. Catches subtle regressions
+    // in the compressZip -> decompressZip path that the size envelope above
+    // would miss (entry truncation, wrong method byte, CRC-vs-data mismatch,
+    // off-by-one in a local file header, etc.).
+    UniqueTemporaryFolder roundtripFolder;
+    ASSERT_TRUE( bool( roundtripFolder ) );
+    const auto decompressRes = decompressZip( zipPath, roundtripFolder );
+    ASSERT_TRUE( decompressRes.has_value() ) << decompressRes.error();
+
+    auto readAllBytes = []( const std::filesystem::path& p ) -> std::vector<char>
+    {
+        std::ifstream in( p, std::ios::binary | std::ios::ate );
+        if ( !in )
+            return {};
+        const std::streamoff sz = in.tellg();
+        in.seekg( 0 );
+        std::vector<char> buf( sz < 0 ? 0 : size_t( sz ) );
+        if ( !buf.empty() )
+            in.read( buf.data(), std::streamsize( buf.size() ) );
+        return buf;
+    };
+
+    int verified = 0;
+    const std::filesystem::path srcRoot = srcFolder;
+    const std::filesystem::path rtRoot  = roundtripFolder;
+    for ( auto entry : DirectoryRecursive{ srcRoot, ec } )
+    {
+        if ( !entry.is_regular_file( ec ) )
+            continue;
+        const auto rel = std::filesystem::relative( entry.path(), srcRoot, ec );
+        const auto dst = rtRoot / rel;
+        ASSERT_TRUE( std::filesystem::exists( dst, ec ) )
+            << "missing in roundtrip: " << rel.generic_string();
+        const auto origBytes = readAllBytes( entry.path() );
+        const auto rtBytes   = readAllBytes( dst );
+        ASSERT_EQ( origBytes.size(), rtBytes.size() )
+            << "size mismatch: " << rel.generic_string();
+        EXPECT_EQ( origBytes, rtBytes )
+            << "content mismatch: " << rel.generic_string();
+        ++verified;
+    }
+    EXPECT_EQ( verified, numBinaryFiles + numJsonFiles );
 }
 
 } // namespace MR