snappy 0.3.0-java → 0.4.0-java

data/vendor/snappy/snappy-test.h

@@ -31,161 +31,91 @@
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_
 
-#include <iostream>
-#include <string>
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include "snappy-stubs-internal.h"
 
-#include <stdio.h>
-#include <stdarg.h>
-
-#ifdef HAVE_SYS_MMAN_H
+#if HAVE_SYS_MMAN_H
 #include <sys/mman.h>
 #endif
 
-#ifdef HAVE_SYS_RESOURCE_H
+#if HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
 
-#ifdef HAVE_SYS_TIME_H
+#if HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
 
-#ifdef HAVE_WINDOWS_H
+#if HAVE_WINDOWS_H
+// Needed to be able to use std::max without workarounds in the source code.
+// https://support.microsoft.com/en-us/help/143208/prb-using-stl-in-windows-program-can-cause-min-max-conflicts
+#define NOMINMAX
 #include <windows.h>
 #endif
 
-#ifdef HAVE_GTEST
-
-#include <gtest/gtest.h>
-#undef TYPED_TEST
-#define TYPED_TEST TEST
-#define INIT_GTEST(argc, argv) ::testing::InitGoogleTest(argc, *argv)
-
-#else
-
-// Stubs for if the user doesn't have Google Test installed.
-
-#define TEST(test_case, test_subcase) \
-  void Test_ ## test_case ## _ ## test_subcase()
-#define INIT_GTEST(argc, argv)
-
-#define TYPED_TEST TEST
-#define EXPECT_EQ CHECK_EQ
-#define EXPECT_NE CHECK_NE
-#define EXPECT_FALSE(cond) CHECK(!(cond))
-
-#endif
-
-#ifdef HAVE_GFLAGS
-
-#include <gflags/gflags.h>
-
-// This is tricky; both gflags and Google Test want to look at the command line
-// arguments. Google Test seems to be the most happy with unknown arguments,
-// though, so we call it first and hope for the best.
-#define InitGoogle(argv0, argc, argv, remove_flags) \
-  INIT_GTEST(argc, argv); \
-  google::ParseCommandLineFlags(argc, argv, remove_flags);
-
-#else
+#define InitGoogle(argv0, argc, argv, remove_flags) ((void)(0))
 
-// If we don't have the gflags package installed, these can only be
-// changed at compile time.
-#define DEFINE_int32(flag_name, default_value, description) \
-  static int FLAGS_ ## flag_name = default_value;
-
-#define InitGoogle(argv0, argc, argv, remove_flags) \
-  INIT_GTEST(argc, argv)
-
-#endif
-
-#ifdef HAVE_LIBZ
+#if HAVE_LIBZ
 #include "zlib.h"
 #endif
 
-#ifdef HAVE_LIBLZO2
+#if HAVE_LIBLZO2
 #include "lzo/lzo1x.h"
 #endif
 
-namespace {
+#if HAVE_LIBLZ4
+#include "lz4.h"
+#endif
 
 namespace file {
-  int Defaults() { return 0; }
-
-  class DummyStatus {
-   public:
-    void CheckSuccess() { }
-  };
-
-  DummyStatus GetContents(
-      const std::string& filename, std::string* data, int unused) {
-    FILE* fp = fopen(filename.c_str(), "rb");
-    if (fp == NULL) {
-      perror(filename.c_str());
-      exit(1);
-    }
-
-    data->clear();
-    while (!feof(fp)) {
-      char buf[4096];
-      size_t ret = fread(buf, 1, 4096, fp);
-      if (ret == 0 && ferror(fp)) {
-        perror("fread");
-        exit(1);
-      }
-      data->append(std::string(buf, ret));
-    }
-
-    fclose(fp);
-
-    return DummyStatus();
-  }
 
-  inline DummyStatus SetContents(
-      const std::string& filename, const std::string& str, int unused) {
-    FILE* fp = fopen(filename.c_str(), "wb");
-    if (fp == NULL) {
-      perror(filename.c_str());
-      exit(1);
-    }
+// Stubs the class file::Options.
+//
+// This class should not be instantiated explicitly. It should only be used by
+// passing file::Defaults() to file::GetContents() / file::SetContents().
+class OptionsStub {
+ public:
+  OptionsStub();
+  OptionsStub(const OptionsStub &) = delete;
+  OptionsStub &operator=(const OptionsStub &) = delete;
+  ~OptionsStub();
+};
 
-    int ret = fwrite(str.data(), str.size(), 1, fp);
-    if (ret != 1) {
-      perror("fwrite");
-      exit(1);
-    }
+const OptionsStub &Defaults();
 
-    fclose(fp);
+// Stubs the class absl::Status.
+//
+// This class should not be instantiated explicitly. It should only be used by
+// passing the result of file::GetContents() / file::SetContents() to
+// CHECK_OK().
+class StatusStub {
+ public:
+  StatusStub();
+  StatusStub(const StatusStub &);
+  StatusStub &operator=(const StatusStub &);
+  ~StatusStub();
 
-    return DummyStatus();
-  }
-}  // namespace file
+  bool ok();
+};
 
-}  // namespace
+StatusStub GetContents(const std::string &file_name, std::string *output,
+                       const OptionsStub & /* options */);
+
+StatusStub SetContents(const std::string &file_name, const std::string &content,
+                       const OptionsStub & /* options */);
+
+}  // namespace file
 
 namespace snappy {
 
 #define FLAGS_test_random_seed 301
-using TypeParam = std::string;
-
-void Test_CorruptedTest_VerifyCorrupted();
-void Test_Snappy_SimpleTests();
-void Test_Snappy_MaxBlowup();
-void Test_Snappy_RandomData();
-void Test_Snappy_FourByteOffset();
-void Test_SnappyCorruption_TruncatedVarint();
-void Test_SnappyCorruption_UnterminatedVarint();
-void Test_SnappyCorruption_OverflowingVarint();
-void Test_Snappy_ReadPastEndOfBuffer();
-void Test_Snappy_FindMatchLength();
-void Test_Snappy_FindMatchLengthRandom();
 
 std::string ReadTestDataFile(const std::string& base, size_t size_limit);
 
-std::string ReadTestDataFile(const std::string& base);
-
-// A sprintf() variant that returns a std::string.
+// A std::sprintf() variant that returns a std::string.
 // Not safe for general use due to truncation issues.
 std::string StrFormat(const char* format, ...);
 
@@ -193,17 +123,18 @@ std::string StrFormat(const char* format, ...);
 // system time changing.
 class CycleTimer {
  public:
-  CycleTimer() : real_time_us_(0) {}
+  inline CycleTimer() : real_time_us_(0) {}
+  inline ~CycleTimer() = default;
 
-  void Start() {
+  inline void Start() {
 #ifdef WIN32
     QueryPerformanceCounter(&start_);
 #else
-    gettimeofday(&start_, NULL);
+    ::gettimeofday(&start_, nullptr);
 #endif
   }
 
-  void Stop() {
+  inline void Stop() {
 #ifdef WIN32
     LARGE_INTEGER stop;
     LARGE_INTEGER frequency;
@@ -214,67 +145,78 @@ class CycleTimer {
         frequency.QuadPart;
     real_time_us_ += elapsed * 1e6 + 0.5;
 #else
-    struct timeval stop;
-    gettimeofday(&stop, NULL);
+    struct ::timeval stop;
+    ::gettimeofday(&stop, nullptr);
 
     real_time_us_ += 1000000 * (stop.tv_sec - start_.tv_sec);
     real_time_us_ += (stop.tv_usec - start_.tv_usec);
 #endif
   }
 
-  double Get() {
-    return real_time_us_ * 1e-6;
-  }
+  inline double Get() { return real_time_us_ * 1e-6; }
 
  private:
-  int64 real_time_us_;
+  int64_t real_time_us_;
 #ifdef WIN32
   LARGE_INTEGER start_;
 #else
-  struct timeval start_;
+  struct ::timeval start_;
 #endif
 };
 
-// Minimalistic microbenchmark framework.
+// Logging.
+
+class LogMessage {
+ public:
+  inline LogMessage() = default;
+  ~LogMessage();
 
-typedef void (*BenchmarkFunction)(int, int);
+  LogMessage &operator<<(const std::string &message);
+  LogMessage &operator<<(int number);
+};
 
-class Benchmark {
+class LogMessageCrash : public LogMessage {
  public:
-  Benchmark(const std::string& name, BenchmarkFunction function)
-      : name_(name), function_(function) {}
+  inline LogMessageCrash() = default;
+  ~LogMessageCrash();
+};
 
-  Benchmark* DenseRange(int start, int stop) {
-    start_ = start;
-    stop_ = stop;
-    return this;
-  }
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
 
-  void Run();
+class LogMessageVoidify {
+ public:
+  inline LogMessageVoidify() = default;
+  inline ~LogMessageVoidify() = default;
 
- private:
-  const std::string name_;
-  const BenchmarkFunction function_;
-  int start_, stop_;
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  inline void operator&(const LogMessage &) {}
 };
-#define BENCHMARK(benchmark_name) \
-  Benchmark* Benchmark_ ## benchmark_name = \
-          (new Benchmark(#benchmark_name, benchmark_name))
 
-extern Benchmark* Benchmark_BM_UFlat;
-extern Benchmark* Benchmark_BM_UIOVec;
-extern Benchmark* Benchmark_BM_UValidate;
-extern Benchmark* Benchmark_BM_ZFlat;
-extern Benchmark* Benchmark_BM_ZFlatAll;
-extern Benchmark* Benchmark_BM_ZFlatIncreasingTableSize;
+// Asserts, both versions activated in debug mode only,
+// and ones that are always active.
 
-void ResetBenchmarkTiming();
-void StartBenchmarkTiming();
-void StopBenchmarkTiming();
-void SetBenchmarkLabel(const std::string& str);
-void SetBenchmarkBytesProcessed(int64 bytes);
+#define CRASH_UNLESS(condition)  \
+  SNAPPY_PREDICT_TRUE(condition) \
+      ? (void)0                  \
+      : snappy::LogMessageVoidify() & snappy::LogMessageCrash()
+
+#define LOG(level) LogMessage()
+#define VLOG(level) \
+  true ? (void)0 : snappy::LogMessageVoidify() & snappy::LogMessage()
+
+#define CHECK(cond) CRASH_UNLESS(cond)
+#define CHECK_LE(a, b) CRASH_UNLESS((a) <= (b))
+#define CHECK_GE(a, b) CRASH_UNLESS((a) >= (b))
+#define CHECK_EQ(a, b) CRASH_UNLESS((a) == (b))
+#define CHECK_NE(a, b) CRASH_UNLESS((a) != (b))
+#define CHECK_LT(a, b) CRASH_UNLESS((a) < (b))
+#define CHECK_GT(a, b) CRASH_UNLESS((a) > (b))
+#define CHECK_OK(cond) (cond).ok()
 
-#ifdef HAVE_LIBZ
+#if HAVE_LIBZ
 
 // Object-oriented wrapper around zlib.
 class ZLib {
@@ -397,129 +339,4 @@ class ZLib {
 
 }  // namespace snappy
 
-DECLARE_bool(run_microbenchmarks);
-
-static inline void RunSpecifiedBenchmarks() {
-  if (!FLAGS_run_microbenchmarks) {
-    return;
-  }
-
-  fprintf(stderr, "Running microbenchmarks.\n");
-#ifndef NDEBUG
-  fprintf(stderr, "WARNING: Compiled with assertions enabled, will be slow.\n");
-#endif
-#ifndef __OPTIMIZE__
-  fprintf(stderr, "WARNING: Compiled without optimization, will be slow.\n");
-#endif
-  fprintf(stderr, "Benchmark            Time(ns)    CPU(ns) Iterations\n");
-  fprintf(stderr, "---------------------------------------------------\n");
-
-  snappy::Benchmark_BM_UFlat->Run();
-  snappy::Benchmark_BM_UIOVec->Run();
-  snappy::Benchmark_BM_UValidate->Run();
-  snappy::Benchmark_BM_ZFlat->Run();
-  snappy::Benchmark_BM_ZFlatAll->Run();
-  snappy::Benchmark_BM_ZFlatIncreasingTableSize->Run();
-
-  fprintf(stderr, "\n");
-}
-
-#ifndef HAVE_GTEST
-
-static inline int RUN_ALL_TESTS() {
-  fprintf(stderr, "Running correctness tests.\n");
-  snappy::Test_CorruptedTest_VerifyCorrupted();
-  snappy::Test_Snappy_SimpleTests();
-  snappy::Test_Snappy_MaxBlowup();
-  snappy::Test_Snappy_RandomData();
-  snappy::Test_Snappy_FourByteOffset();
-  snappy::Test_SnappyCorruption_TruncatedVarint();
-  snappy::Test_SnappyCorruption_UnterminatedVarint();
-  snappy::Test_SnappyCorruption_OverflowingVarint();
-  snappy::Test_Snappy_ReadPastEndOfBuffer();
-  snappy::Test_Snappy_FindMatchLength();
-  snappy::Test_Snappy_FindMatchLengthRandom();
-  fprintf(stderr, "All tests passed.\n");
-
-  return 0;
-}
-
-#endif  // HAVE_GTEST
-
-// For main().
-namespace snappy {
-
-// Logging.
-
-#define LOG(level) LogMessage()
-#define VLOG(level) true ? (void)0 : \
-    snappy::LogMessageVoidify() & snappy::LogMessage()
-
-class LogMessage {
- public:
-  LogMessage() { }
-  ~LogMessage() {
-    std::cerr << std::endl;
-  }
-
-  LogMessage& operator<<(const std::string& msg) {
-    std::cerr << msg;
-    return *this;
-  }
-  LogMessage& operator<<(int x) {
-    std::cerr << x;
-    return *this;
-  }
-};
-
-// Asserts, both versions activated in debug mode only,
-// and ones that are always active.
-
-#define CRASH_UNLESS(condition) \
-    SNAPPY_PREDICT_TRUE(condition) ? (void)0 : \
-    snappy::LogMessageVoidify() & snappy::LogMessageCrash()
-
-#ifdef _MSC_VER
-// ~LogMessageCrash calls abort() and therefore never exits. This is by design
-// so temporarily disable warning C4722.
-#pragma warning(push)
-#pragma warning(disable:4722)
-#endif
-
-class LogMessageCrash : public LogMessage {
- public:
-  LogMessageCrash() { }
-  ~LogMessageCrash() {
-    std::cerr << std::endl;
-    abort();
-  }
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// This class is used to explicitly ignore values in the conditional
-// logging macros.  This avoids compiler warnings like "value computed
-// is not used" and "statement has no effect".
-
-class LogMessageVoidify {
- public:
-  LogMessageVoidify() { }
-  // This has to be an operator with a precedence lower than << but
-  // higher than ?:
-  void operator&(const LogMessage&) { }
-};
-
-#define CHECK(cond) CRASH_UNLESS(cond)
-#define CHECK_LE(a, b) CRASH_UNLESS((a) <= (b))
-#define CHECK_GE(a, b) CRASH_UNLESS((a) >= (b))
-#define CHECK_EQ(a, b) CRASH_UNLESS((a) == (b))
-#define CHECK_NE(a, b) CRASH_UNLESS((a) != (b))
-#define CHECK_LT(a, b) CRASH_UNLESS((a) < (b))
-#define CHECK_GT(a, b) CRASH_UNLESS((a) > (b))
-#define CHECK_OK(cond) (cond).CheckSuccess()
-
-}  // namespace snappy
-
 #endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_