snappy 0.4.0-java → 0.5.0-java

data/vendor/snappy/snappy_benchmark.cc

@@ -31,12 +31,10 @@
 #include <string>
 #include <vector>
 
-#include "snappy-test.h"
-
 #include "benchmark/benchmark.h"
-
 #include "snappy-internal.h"
 #include "snappy-sinksource.h"
+#include "snappy-test.h"
 #include "snappy.h"
 #include "snappy_test_data.h"
 
@@ -44,6 +42,15 @@ namespace snappy {
 
 namespace {
 
+void FilesAndLevels(benchmark::internal::Benchmark* benchmark) {
+  for (int i = 0; i < ARRAYSIZE(kTestDataFiles); ++i) {
+    for (int level = snappy::CompressionOptions::MinCompressionLevel();
+         level <= snappy::CompressionOptions::MaxCompressionLevel(); ++level) {
+      benchmark->ArgPair(i, level);
+    }
+  }
+}
+
 void BM_UFlat(benchmark::State& state) {
   // Pick file to process based on state.range(0).
   int file_index = state.range(0);
@@ -55,7 +62,9 @@ void BM_UFlat(benchmark::State& state) {
                        kTestDataFiles[file_index].size_limit);
 
   std::string zcontents;
-  snappy::Compress(contents.data(), contents.size(), &zcontents);
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
   char* dst = new char[contents.size()];
 
   for (auto s : state) {
@@ -68,7 +77,7 @@ void BM_UFlat(benchmark::State& state) {
 
   delete[] dst;
 }
-BENCHMARK(BM_UFlat)->DenseRange(0, ARRAYSIZE(kTestDataFiles) - 1);
+BENCHMARK(BM_UFlat)->Apply(FilesAndLevels);
 
 struct SourceFiles {
   SourceFiles() {
@@ -119,7 +128,9 @@ void BM_UValidate(benchmark::State& state) {
                        kTestDataFiles[file_index].size_limit);
 
   std::string zcontents;
-  snappy::Compress(contents.data(), contents.size(), &zcontents);
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
 
   for (auto s : state) {
     CHECK(snappy::IsValidCompressedBuffer(zcontents.data(), zcontents.size()));
@@ -128,7 +139,7 @@ void BM_UValidate(benchmark::State& state) {
                           static_cast<int64_t>(contents.size()));
   state.SetLabel(kTestDataFiles[file_index].label);
 }
-BENCHMARK(BM_UValidate)->DenseRange(0, ARRAYSIZE(kTestDataFiles) - 1);
+BENCHMARK(BM_UValidate)->Apply(FilesAndLevels);
 
 void BM_UValidateMedley(benchmark::State& state) {
   static const SourceFiles* const source = new SourceFiles();
@@ -152,6 +163,7 @@ BENCHMARK(BM_UValidateMedley);
 void BM_UIOVecSource(benchmark::State& state) {
   // Pick file to process based on state.range(0).
   int file_index = state.range(0);
+  int level = state.range(1);
 
   CHECK_GE(file_index, 0);
   CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
@@ -180,7 +192,8 @@ void BM_UIOVecSource(benchmark::State& state) {
   char* dst = new char[snappy::MaxCompressedLength(contents.size())];
   size_t zsize = 0;
   for (auto s : state) {
-    snappy::RawCompressFromIOVec(iov, contents.size(), dst, &zsize);
+    snappy::RawCompressFromIOVec(iov, contents.size(), dst, &zsize,
+                                 snappy::CompressionOptions{/*level=*/level});
     benchmark::DoNotOptimize(iov);
   }
   state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
@@ -195,7 +208,7 @@ void BM_UIOVecSource(benchmark::State& state) {
 
   delete[] dst;
 }
-BENCHMARK(BM_UIOVecSource)->DenseRange(0, ARRAYSIZE(kTestDataFiles) - 1);
+BENCHMARK(BM_UIOVecSource)->Apply(FilesAndLevels);
 
 void BM_UIOVecSink(benchmark::State& state) {
   // Pick file to process based on state.range(0).
@@ -213,7 +226,7 @@ void BM_UIOVecSink(benchmark::State& state) {
   // Uncompress into an iovec containing ten entries.
   const int kNumEntries = 10;
   struct iovec iov[kNumEntries];
-  char *dst = new char[contents.size()];
+  char* dst = new char[contents.size()];
   size_t used_so_far = 0;
   for (int i = 0; i < kNumEntries; ++i) {
     iov[i].iov_base = dst + used_so_far;
@@ -254,7 +267,9 @@ void BM_UFlatSink(benchmark::State& state) {
                        kTestDataFiles[file_index].size_limit);
 
   std::string zcontents;
-  snappy::Compress(contents.data(), contents.size(), &zcontents);
+  snappy::Compress(
+      contents.data(), contents.size(), &zcontents,
+      snappy::CompressionOptions{/*level=*/static_cast<int>(state.range(1))});
   char* dst = new char[contents.size()];
 
   for (auto s : state) {
@@ -273,11 +288,12 @@ void BM_UFlatSink(benchmark::State& state) {
   delete[] dst;
 }
 
-BENCHMARK(BM_UFlatSink)->DenseRange(0, ARRAYSIZE(kTestDataFiles) - 1);
+BENCHMARK(BM_UFlatSink)->Apply(FilesAndLevels);
 
 void BM_ZFlat(benchmark::State& state) {
   // Pick file to process based on state.range(0).
   int file_index = state.range(0);
+  int level = state.range(1);
 
   CHECK_GE(file_index, 0);
   CHECK_LT(file_index, ARRAYSIZE(kTestDataFiles));
@@ -288,7 +304,8 @@ void BM_ZFlat(benchmark::State& state) {
 
   size_t zsize = 0;
   for (auto s : state) {
-    snappy::RawCompress(contents.data(), contents.size(), dst, &zsize);
+    snappy::RawCompress(contents.data(), contents.size(), dst, &zsize,
+                        snappy::CompressionOptions{/*level=*/level});
     benchmark::DoNotOptimize(dst);
   }
   state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) *
@@ -302,10 +319,12 @@ void BM_ZFlat(benchmark::State& state) {
                        zsize);
   delete[] dst;
 }
-BENCHMARK(BM_ZFlat)->DenseRange(0, ARRAYSIZE(kTestDataFiles) - 1);
+
+BENCHMARK(BM_ZFlat)->Apply(FilesAndLevels);
 
 void BM_ZFlatAll(benchmark::State& state) {
   const int num_files = ARRAYSIZE(kTestDataFiles);
+  int level = state.range(0);
 
   std::vector<std::string> contents(num_files);
   std::vector<char*> dst(num_files);
@@ -322,7 +341,7 @@ void BM_ZFlatAll(benchmark::State& state) {
   for (auto s : state) {
     for (int i = 0; i < num_files; ++i) {
       snappy::RawCompress(contents[i].data(), contents[i].size(), dst[i],
-                          &zsize);
+                          &zsize, snappy::CompressionOptions{/*level=*/level});
       benchmark::DoNotOptimize(dst);
     }
   }
@@ -335,10 +354,11 @@ void BM_ZFlatAll(benchmark::State& state) {
   }
   state.SetLabel(StrFormat("%d kTestDataFiles", num_files));
 }
-BENCHMARK(BM_ZFlatAll);
+BENCHMARK(BM_ZFlatAll)->DenseRange(1, 2);
 
 void BM_ZFlatIncreasingTableSize(benchmark::State& state) {
   CHECK_GT(ARRAYSIZE(kTestDataFiles), 0);
+  int level = state.range(0);
   const std::string base_content = ReadTestDataFile(
       kTestDataFiles[0].filename, kTestDataFiles[0].size_limit);
 
@@ -358,7 +378,7 @@ void BM_ZFlatIncreasingTableSize(benchmark::State& state) {
   for (auto s : state) {
     for (size_t i = 0; i < contents.size(); ++i) {
       snappy::RawCompress(contents[i].data(), contents[i].size(), dst[i],
-                          &zsize);
+                          &zsize, snappy::CompressionOptions{/*level=*/level});
       benchmark::DoNotOptimize(dst);
     }
   }
@@ -371,7 +391,7 @@ void BM_ZFlatIncreasingTableSize(benchmark::State& state) {
   }
   state.SetLabel(StrFormat("%d tables", contents.size()));
 }
-BENCHMARK(BM_ZFlatIncreasingTableSize);
+BENCHMARK(BM_ZFlatIncreasingTableSize)->DenseRange(1, 2);
 
 }  // namespace
 

data/vendor/snappy/snappy_compress_fuzzer.cc

@@ -39,22 +39,26 @@
 // Entry point for LibFuzzer.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   std::string input(reinterpret_cast<const char*>(data), size);
+  for (int level = snappy::CompressionOptions::MinCompressionLevel();
+       level <= snappy::CompressionOptions::MaxCompressionLevel(); ++level) {
+    std::string compressed;
+    size_t compressed_size =
+        snappy::Compress(input.data(), input.size(), &compressed,
+                         snappy::CompressionOptions{/*level=*/level});
 
-  std::string compressed;
-  size_t compressed_size =
-      snappy::Compress(input.data(), input.size(), &compressed);
+    (void)compressed_size;  // Variable only used in debug builds.
+    assert(compressed_size == compressed.size());
+    assert(compressed.size() <= snappy::MaxCompressedLength(input.size()));
+    assert(
+        snappy::IsValidCompressedBuffer(compressed.data(), compressed.size()));
 
-  (void)compressed_size;  // Variable only used in debug builds.
-  assert(compressed_size == compressed.size());
-  assert(compressed.size() <= snappy::MaxCompressedLength(input.size()));
-  assert(snappy::IsValidCompressedBuffer(compressed.data(), compressed.size()));
+    std::string uncompressed_after_compress;
+    bool uncompress_succeeded = snappy::Uncompress(
+        compressed.data(), compressed.size(), &uncompressed_after_compress);
 
-  std::string uncompressed_after_compress;
-  bool uncompress_succeeded = snappy::Uncompress(
-      compressed.data(), compressed.size(), &uncompressed_after_compress);
-
-  (void)uncompress_succeeded;  // Variable only used in debug builds.
-  assert(uncompress_succeeded);
-  assert(input == uncompressed_after_compress);
+    (void)uncompress_succeeded;  // Variable only used in debug builds.
+    assert(uncompress_succeeded);
+    assert(input == uncompressed_after_compress);
+  }
   return 0;
 }

data/vendor/snappy/snappy_unittest.cc

@@ -27,6 +27,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <algorithm>
+#include <cinttypes>
 #include <cmath>
 #include <cstdlib>
 #include <random>
@@ -484,6 +485,18 @@ TEST(Snappy, MaxBlowup) {
   Verify(input);
 }
 
+// Issue #201, when output is more than 4GB, we had a data corruption bug.
+// We cannot run this test always because of CI constraints.
+TEST(Snappy, DISABLED_MoreThan4GB) {
+  std::mt19937 rng;
+  std::uniform_int_distribution<int> uniform_byte(0, 255);
+  std::string input;
+  input.resize((1ull << 32) - 1);
+  for (uint64_t i = 0; i < ((1ull << 32) - 1); ++i)
+    input[i] = static_cast<char>(uniform_byte(rng));
+  Verify(input);
+}
+
 TEST(Snappy, RandomData) {
   std::minstd_rand0 rng(snappy::GetFlag(FLAGS_test_random_seed));
   std::uniform_int_distribution<int> uniform_0_to_3(0, 3);

metadata

@@ -1,22 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: snappy
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: java
 authors:
 - miyucy
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: snappy-jars
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
-  name: snappy-jars
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -64,11 +63,15 @@ files:
 - test/snappy_writer_test.rb
 - test/test_helper.rb
 - vendor/snappy/AUTHORS
+- vendor/snappy/BUILD.bazel
 - vendor/snappy/CMakeLists.txt
 - vendor/snappy/CONTRIBUTING.md
 - vendor/snappy/COPYING
+- vendor/snappy/MODULE.bazel
 - vendor/snappy/NEWS
 - vendor/snappy/README.md
+- vendor/snappy/WORKSPACE
+- vendor/snappy/WORKSPACE.bzlmod
 - vendor/snappy/cmake/SnappyConfig.cmake.in
 - vendor/snappy/cmake/config.h.in
 - vendor/snappy/docs/README.md
@@ -99,7 +102,6 @@ licenses:
 metadata:
   homepage_uri: http://github.com/miyucy/snappy
   source_code_uri: http://github.com/miyucy/snappy
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -114,8 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: libsnappy binding for Ruby
 test_files: