snappy 0.0.17 → 0.4.0

data/vendor/snappy/snappy-test.h

@@ -31,249 +31,110 @@
 #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
 
-#include <string>
-
-#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
-
-// 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) ((void)(0))
 
-#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
 
-#ifdef HAVE_LIBLZF
-extern "C" {
-#include "lzf.h"
-}
-#endif
-
-#ifdef HAVE_LIBFASTLZ
-#include "fastlz.h"
+#if HAVE_LIBLZ4
+#include "lz4.h"
 #endif
 
-#ifdef HAVE_LIBQUICKLZ
-#include "quicklz.h"
-#endif
+namespace file {
 
-namespace {
+// 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();
+};
 
-namespace File {
-  void Init() { }
-}  // namespace File
+const OptionsStub &Defaults();
 
-namespace file {
-  int Defaults() { return 0; }
-
-  class DummyStatus {
-   public:
-    void CheckSuccess() { }
-  };
-
-  DummyStatus GetContents(const string& filename, 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(string(buf, ret));
-    }
-
-    fclose(fp);
-
-    return DummyStatus();
-  }
+// 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();
 
-  DummyStatus SetContents(const string& filename,
-                          const string& str,
-                          int unused) {
-    FILE* fp = fopen(filename.c_str(), "wb");
-    if (fp == NULL) {
-      perror(filename.c_str());
-      exit(1);
-    }
+  bool ok();
+};
 
-    int ret = fwrite(str.data(), str.size(), 1, fp);
-    if (ret != 1) {
-      perror("fwrite");
-      exit(1);
-    }
+StatusStub GetContents(const std::string &file_name, std::string *output,
+                       const OptionsStub & /* options */);
 
-    fclose(fp);
+StatusStub SetContents(const std::string &file_name, const std::string &content,
+                       const OptionsStub & /* options */);
 
-    return DummyStatus();
-  }
 }  // namespace file
 
-}  // namespace
-
 namespace snappy {
 
 #define FLAGS_test_random_seed 301
-typedef string TypeParam;
-
-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();
-
-string ReadTestDataFile(const string& base, size_t size_limit);
 
-string ReadTestDataFile(const string& base);
+std::string ReadTestDataFile(const std::string& base, size_t size_limit);
 
-// 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.
-string StringPrintf(const char* format, ...);
-
-// A simple, non-cryptographically-secure random generator.
-class ACMRandom {
- public:
-  explicit ACMRandom(uint32 seed) : seed_(seed) {}
-
-  int32 Next();
-
-  int32 Uniform(int32 n) {
-    return Next() % n;
-  }
-  uint8 Rand8() {
-    return static_cast<uint8>((Next() >> 1) & 0x000000ff);
-  }
-  bool OneIn(int X) { return Uniform(X) == 0; }
-
-  // Skewed: pick "base" uniformly from range [0,max_log] and then
-  // return "base" random bits.  The effect is to pick a number in the
-  // range [0,2^max_log-1] with bias towards smaller numbers.
-  int32 Skewed(int max_log);
-
- private:
-  static const uint32 M = 2147483647L;   // 2^31-1
-  uint32 seed_;
-};
-
-inline int32 ACMRandom::Next() {
-  static const uint64 A = 16807;  // bits 14, 8, 7, 5, 2, 1, 0
-  // We are computing
-  //       seed_ = (seed_ * A) % M,    where M = 2^31-1
-  //
-  // seed_ must not be zero or M, or else all subsequent computed values
-  // will be zero or M respectively.  For all other values, seed_ will end
-  // up cycling through every number in [1,M-1]
-  uint64 product = seed_ * A;
-
-  // Compute (product % M) using the fact that ((x << 31) % M) == x.
-  seed_ = (product >> 31) + (product & M);
-  // The first reduction may overflow by 1 bit, so we may need to repeat.
-  // mod == M is not possible; using > allows the faster sign-bit-based test.
-  if (seed_ > M) {
-    seed_ -= M;
-  }
-  return seed_;
-}
-
-inline int32 ACMRandom::Skewed(int max_log) {
-  const int32 base = (Next() - 1) % (max_log+1);
-  return (Next() - 1) & ((1u << base)-1);
-}
+std::string StrFormat(const char* format, ...);
 
 // A wall-time clock. This stub is not super-accurate, nor resistant to the
 // 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;
@@ -284,65 +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 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 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;
+// Asserts, both versions activated in debug mode only,
+// and ones that are always active.
 
-void ResetBenchmarkTiming();
-void StartBenchmarkTiming();
-void StopBenchmarkTiming();
-void SetBenchmarkLabel(const string& str);
-void SetBenchmarkBytesProcessed(int64 bytes);
+#define CRASH_UNLESS(condition)  \
+  SNAPPY_PREDICT_TRUE(condition) \
+      ? (void)0                  \
+      : snappy::LogMessageVoidify() & snappy::LogMessageCrash()
 
-#ifdef HAVE_LIBZ
+#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()
+
+#if HAVE_LIBZ
 
 // Object-oriented wrapper around zlib.
 class ZLib {
@@ -465,135 +339,4 @@ class ZLib {
 
 }  // namespace snappy
 
-DECLARE_bool(run_microbenchmarks);
-
-static 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();
-
-  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 {
-
-static void CompressFile(const char* fname);
-static void UncompressFile(const char* fname);
-static void MeasureFile(const char* fname);
-
-// Logging.
-
-#define LOG(level) LogMessage()
-#define VLOG(level) true ? (void)0 : \
-    snappy::LogMessageVoidify() & snappy::LogMessage()
-
-class LogMessage {
- public:
-  LogMessage() { }
-  ~LogMessage() {
-    cerr << endl;
-  }
-
-  LogMessage& operator<<(const std::string& msg) {
-    cerr << msg;
-    return *this;
-  }
-  LogMessage& operator<<(int x) {
-    cerr << x;
-    return *this;
-  }
-};
-
-// Asserts, both versions activated in debug mode only,
-// and ones that are always active.
-
-#define CRASH_UNLESS(condition) \
-    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() {
-    cerr << 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
-
-using snappy::CompressFile;
-using snappy::UncompressFile;
-using snappy::MeasureFile;
-
 #endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_TEST_H_