snappy 0.1.0 → 0.2.0

data/test/hadoop/snappy_hadoop_writer_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopWriterTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+  end
+
+  def subject
+    @subject ||= Snappy::Hadoop::Writer.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Hadoop::Writer.new @buffer do |w|
+        yielded = w
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should write the header" do
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      assert_equal "\u0000\u0000\u0000\u0003\u0000\u0000\u0000\u0005\u0003\bfoo", @buffer.string
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      io = StringIO.new
+      assert_equal io, Snappy::Hadoop::Writer.new(io).io
+    end
+  end
+
+  sub_test_case "#block_size" do
+    test "should default to DEFAULT_BLOCK_SIZE" do
+      assert_equal Snappy::Hadoop::Writer::DEFAULT_BLOCK_SIZE, subject.block_size
+    end
+
+    test "should be settable via the constructor" do
+      assert_equal 42, Snappy::Hadoop::Writer.new(StringIO.new, 42).block_size
+    end
+  end
+end

data/test/snappy_hadoop_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopTest < Test::Unit::TestCase
+  T = [*"a".."z", *"A".."Z", *"0".."9"].freeze
+
+  def random_data(length = 1024)
+    Array.new(length) { T.sample }.join
+  end
+
+  test "well done" do
+    s = random_data
+    assert_equal s, Snappy::Hadoop.inflate(Snappy::Hadoop.deflate(s))
+  end
+
+  test "well done(pair)" do
+    s = random_data
+    [
+      %i[deflate inflate]
+    ].each do |(i, o)|
+      assert_equal s, Snappy::Hadoop.__send__(o, Snappy::Hadoop.__send__(i, s))
+    end
+  end
+end

data/test/snappy_reader_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyReaderTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    Snappy::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  def subject
+    @subject ||= Snappy::Reader.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Reader.new @buffer do |r|
+        yielded = r
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should read the header" do
+      assert_equal Snappy::Writer::MAGIC, subject.magic
+      assert_equal Snappy::Writer::DEFAULT_VERSION, subject.default_version
+      assert_equal Snappy::Writer::MINIMUM_COMPATIBLE_VERSION, subject.minimum_compatible_version
+    end
+  end
+
+  sub_test_case :initialize_without_headers do
+    def setup
+      @buffer = StringIO.new
+      @buffer << Snappy.deflate("HelloWorld" * 10)
+      @buffer.rewind
+    end
+
+    test "should inflate with a magic header" do
+      assert_equal "HelloWorld" * 10, subject.read
+    end
+
+    test "should not receive `length' in eaching" do
+      dont_allow(@buffer).length
+      subject.read
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      assert_equal @buffer, subject.io
+    end
+
+    test "should not receive `length' in initializing" do
+      dont_allow(@buffer).length
+      Snappy::Reader.new @buffer
+    end
+  end
+
+  sub_test_case "#each" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each chunk" do
+      chunks = []
+      subject.each do |chunk|
+        chunks << chunk
+      end
+      assert_equal %w[foobar bazquux], chunks
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each
+      assert_instance_of Enumerator, eacher
+      chunks = []
+      chunks << eacher.next
+      chunks << eacher.next
+      assert_raise(StopIteration) { eacher.next }
+      assert_equal %w[foobar bazquux], chunks
+    end
+  end
+
+  sub_test_case "#read" do
+    test "should return the bytes" do
+      assert_equal "foobarbazquux", subject.read
+    end
+  end
+
+  sub_test_case "#each_line" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each line" do
+      lines = []
+      subject.each_line do |line|
+        lines << line
+      end
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each_line
+      assert_instance_of Enumerator, eacher
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "each_line split by sep_string" do
+      buffer = StringIO.new
+      Snappy::Writer.new buffer do |w|
+        w << %w[a b c].join(",")
+        w.dump!
+        w << %w[d e f].join(",")
+      end
+      buffer.rewind
+      reader = Snappy::Reader.new buffer
+      eacher = reader.each_line(",")
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[a b cd e f], lines
+    end
+  end
+end

data/test/snappy_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class SnappyTest < Test::Unit::TestCase
+  T = [*"a".."z", *"A".."Z", *"0".."9"].freeze
+
+  def random_data(length = 1024)
+    Array.new(length) { T.sample }.join
+  end
+
+  test "VERSION" do
+    assert do
+      ::Snappy.const_defined?(:VERSION)
+    end
+  end
+
+  test "well done" do
+    s = random_data
+    assert_equal s, Snappy.inflate(Snappy.deflate(s))
+  end
+
+  test "well done (pair)" do
+    s = random_data
+    [
+      %i[deflate inflate],
+      %i[compress uncompress],
+      %i[dump load]
+    ].each do |(i, o)|
+      assert_equal s, Snappy.__send__(o, Snappy.__send__(i, s))
+    end
+  end
+
+  sub_test_case ".deflate" do
+    test "can pass buffer" do
+      if defined? JRUBY_VERSION
+        notify "cannot pass buffer in jruby"
+        omit
+      end
+      s = random_data
+      d = " " * 1024
+      r = Snappy.deflate(s, d)
+      assert_equal r.object_id, d.object_id
+    end
+  end
+
+  sub_test_case ".inflate" do
+    test "can pass buffer" do
+      if defined? JRUBY_VERSION
+        notify "cannot pass buffer in jruby"
+        omit
+      end
+      s = Snappy.deflate(random_data)
+      d = " " * 1024
+      r = Snappy.inflate(s, d)
+      assert_equal r.object_id, d.object_id
+    end
+  end
+
+  sub_test_case ".valid?" do
+    test "return true when passed deflated data" do
+      if defined? JRUBY_VERSION
+        notify "snappy-jars does not have valid?"
+        omit
+      end
+      d = Snappy.deflate(random_data)
+      assert_true Snappy.valid?(d)
+    end
+
+    test "return false when passed invalid data" do
+      if defined? JRUBY_VERSION
+        notify "snappy-jars does not have valid?"
+        omit
+      end
+      d = Snappy.deflate(random_data).reverse
+      assert_false Snappy.valid?(d)
+    end
+  end
+
+  sub_test_case "Ractor safe" do
+    test "able to invoke non-main ractor" do
+      unless defined? ::Ractor
+        notify "Ractor not defined"
+        omit
+      end
+      s = random_data
+      a = Array.new(2) do
+        Ractor.new(s) do |s|
+          Snappy.inflate(Snappy.deflate(s)) == s
+        end
+      end
+      assert_equal [true, true], a.map(&:take)
+    end
+  end
+end

data/test/snappy_writer_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyWriterTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+  end
+
+  def subject
+    @subject ||= Snappy::Writer.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Writer.new @buffer do |w|
+        yielded = w
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should write the header" do
+      assert_equal [Snappy::Writer::MAGIC,
+                    Snappy::Writer::DEFAULT_VERSION,
+                    Snappy::Writer::MINIMUM_COMPATIBLE_VERSION].pack("a8NN"), subject.io.string
+    end
+
+    test "should dump on the end of yield" do
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      foo = Snappy.deflate "foo"
+      assert_equal [foo.size, foo].pack("Na#{foo.size}"), @buffer.string[16, @buffer.size - 16]
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      io = StringIO.new
+      assert_equal io, Snappy::Writer.new(io).io
+    end
+  end
+
+  sub_test_case "#block_size" do
+    test "should default to DEFAULT_BLOCK_SIZE" do
+      assert_equal Snappy::Writer::DEFAULT_BLOCK_SIZE, subject.block_size
+    end
+
+    test "should be settable via the constructor" do
+      assert_equal 42, Snappy::Writer.new(StringIO.new, 42).block_size
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "snappy"
+
+require "test-unit"
+require "test/unit/rr"

data/vendor/snappy/CMakeLists.txt

@@ -1,5 +1,41 @@
+# Copyright 2019 Google Inc. All Rights Reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 cmake_minimum_required(VERSION 3.1)
-project(Snappy VERSION 1.1.7 LANGUAGES C CXX)
+project(Snappy VERSION 1.1.8 LANGUAGES C CXX)
+
+# C++ standard can be overridden when this is used as a sub-project.
+if(NOT CMAKE_CXX_STANDARD)
+  # This project requires C++11.
+  set(CMAKE_CXX_STANDARD 11)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  set(CMAKE_CXX_EXTENSIONS OFF)
+endif(NOT CMAKE_CXX_STANDARD)
 
 # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make
 # it prominent in the GUI.
@@ -7,13 +43,19 @@ option(BUILD_SHARED_LIBS "Build shared libraries(DLLs)." OFF)
 
 option(SNAPPY_BUILD_TESTS "Build Snappy's own tests." ON)
 
+option(SNAPPY_FUZZING_BUILD "Build Snappy for fuzzing." OFF)
+
+option(SNAPPY_REQUIRE_AVX "Target processors with AVX support." OFF)
+
+option(SNAPPY_REQUIRE_AVX2 "Target processors with AVX2 support." OFF)
+
+option(SNAPPY_INSTALL "Install Snappy's header and library" ON)
+
 include(TestBigEndian)
 test_big_endian(SNAPPY_IS_BIG_ENDIAN)
 
 include(CheckIncludeFile)
 check_include_file("byteswap.h" HAVE_BYTESWAP_H)
-check_include_file("stddef.h" HAVE_STDDEF_H)
-check_include_file("stdint.h" HAVE_STDINT_H)
 check_include_file("sys/endian.h" HAVE_SYS_ENDIAN_H)
 check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
 check_include_file("sys/resource.h" HAVE_SYS_RESOURCE_H)
@@ -26,12 +68,58 @@ include(CheckLibraryExists)
 check_library_exists(z zlibVersion "" HAVE_LIBZ)
 check_library_exists(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2)
 
+include(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG("/arch:AVX" HAVE_VISUAL_STUDIO_ARCH_AVX)
+CHECK_CXX_COMPILER_FLAG("/arch:AVX2" HAVE_VISUAL_STUDIO_ARCH_AVX2)
+CHECK_CXX_COMPILER_FLAG("-mavx" HAVE_CLANG_MAVX)
+CHECK_CXX_COMPILER_FLAG("-mbmi2" HAVE_CLANG_MBMI2)
+if(SNAPPY_REQUIRE_AVX2)
+  if(HAVE_VISUAL_STUDIO_ARCH_AVX2)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
+  endif(HAVE_VISUAL_STUDIO_ARCH_AVX2)
+  if(HAVE_CLANG_MAVX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
+  endif(HAVE_CLANG_MAVX)
+  if(HAVE_CLANG_MBMI2)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mbmi2")
+  endif(HAVE_CLANG_MBMI2)
+elseif (SNAPPY_REQUIRE_AVX)
+  if(HAVE_VISUAL_STUDIO_ARCH_AVX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX")
+  endif(HAVE_VISUAL_STUDIO_ARCH_AVX)
+  if(HAVE_CLANG_MAVX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
+  endif(HAVE_CLANG_MAVX)
+endif(SNAPPY_REQUIRE_AVX2)
+
 include(CheckCXXSourceCompiles)
-check_cxx_source_compiles(
-    "int main(void) { return __builtin_expect(0, 1); }" HAVE_BUILTIN_EXPECT)
+check_cxx_source_compiles("
+int main() {
+  return __builtin_expect(0, 1);
+}" HAVE_BUILTIN_EXPECT)
+
+check_cxx_source_compiles("
+int main() {
+  return __builtin_ctzll(0);
+}" HAVE_BUILTIN_CTZ)
 
-check_cxx_source_compiles(
-    "int main(void) { return __builtin_ctzll(0); }" HAVE_BUILTIN_CTZ)
+check_cxx_source_compiles("
+#include <tmmintrin.h>
+
+int main() {
+  const __m128i *src = 0;
+  __m128i dest;
+  const __m128i shuffle_mask = _mm_load_si128(src);
+  const __m128i pattern = _mm_shuffle_epi8(_mm_loadl_epi64(src), shuffle_mask);
+  _mm_storeu_si128(&dest, pattern);
+  return 0;
+}" SNAPPY_HAVE_SSSE3)
+
+check_cxx_source_compiles("
+#include <immintrin.h>
+int main() {
+  return _bzhi_u32(0, 1);
+}" SNAPPY_HAVE_BMI2)
 
 include(CheckSymbolExists)
 check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
@@ -48,39 +136,45 @@ if(GFLAGS_FOUND)
 endif(GFLAGS_FOUND)
 
 configure_file(
-  "${PROJECT_SOURCE_DIR}/cmake/config.h.in"
+  "cmake/config.h.in"
   "${PROJECT_BINARY_DIR}/config.h"
 )
 
 # We don't want to define HAVE_ macros in public headers. Instead, we use
 # CMake's variable substitution with 0/1 variables, which will be seen by the
 # preprocessor as constants.
-set(HAVE_STDINT_H_01  ${HAVE_STDINT_H})
-set(HAVE_STDDEF_H_01  ${HAVE_STDDEF_H})
 set(HAVE_SYS_UIO_H_01 ${HAVE_SYS_UIO_H})
-if(NOT HAVE_STDINT_H_01)
-  set(HAVE_STDINT_H_01 0)
-endif(NOT HAVE_STDINT_H_01)
-if(NOT HAVE_STDDEF_H_01)
-  set(HAVE_STDDEF_H_01 0)
-endif(NOT HAVE_STDDEF_H_01)
 if(NOT HAVE_SYS_UIO_H_01)
   set(HAVE_SYS_UIO_H_01 0)
 endif(NOT HAVE_SYS_UIO_H_01)
 
+if (SNAPPY_FUZZING_BUILD)
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+    message(WARNING "Fuzzing builds are only supported with Clang")
+  endif (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+
+  if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
+  endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=address")
+
+  if(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=fuzzer-no-link")
+  endif(NOT CMAKE_CXX_FLAGS MATCHES "-fsanitize=fuzzer-no-link")
+endif (SNAPPY_FUZZING_BUILD)
+
 configure_file(
-  "${PROJECT_SOURCE_DIR}/snappy-stubs-public.h.in"
+  "snappy-stubs-public.h.in"
   "${PROJECT_BINARY_DIR}/snappy-stubs-public.h")
 
 add_library(snappy "")
 target_sources(snappy
   PRIVATE
-    "${PROJECT_SOURCE_DIR}/snappy-internal.h"
-    "${PROJECT_SOURCE_DIR}/snappy-stubs-internal.h"
-    "${PROJECT_SOURCE_DIR}/snappy-c.cc"
-    "${PROJECT_SOURCE_DIR}/snappy-sinksource.cc"
-    "${PROJECT_SOURCE_DIR}/snappy-stubs-internal.cc"
-    "${PROJECT_SOURCE_DIR}/snappy.cc"
+    "snappy-internal.h"
+    "snappy-stubs-internal.h"
+    "snappy-c.cc"
+    "snappy-sinksource.cc"
+    "snappy-stubs-internal.cc"
+    "snappy.cc"
     "${PROJECT_BINARY_DIR}/config.h"
 
   # Only CMake 3.3+ supports PUBLIC sources in targets exported by "install".
@@ -114,8 +208,8 @@ if(SNAPPY_BUILD_TESTS)
   add_executable(snappy_unittest "")
   target_sources(snappy_unittest
     PRIVATE
-      "${PROJECT_SOURCE_DIR}/snappy_unittest.cc"
-      "${PROJECT_SOURCE_DIR}/snappy-test.cc"
+      "snappy_unittest.cc"
+      "snappy-test.cc"
   )
   target_compile_definitions(snappy_unittest PRIVATE -DHAVE_CONFIG_H)
   target_link_libraries(snappy_unittest snappy ${GFLAGS_LIBRARIES})
@@ -140,35 +234,64 @@ if(SNAPPY_BUILD_TESTS)
     COMMAND "${PROJECT_BINARY_DIR}/snappy_unittest")
 endif(SNAPPY_BUILD_TESTS)
 
+if(SNAPPY_FUZZING_BUILD)
+  add_executable(snappy_compress_fuzzer "")
+  target_sources(snappy_compress_fuzzer
+    PRIVATE "snappy_compress_fuzzer.cc"
+  )
+  target_link_libraries(snappy_compress_fuzzer snappy)
+  set_target_properties(snappy_compress_fuzzer
+    PROPERTIES LINK_FLAGS "-fsanitize=fuzzer"
+  )
+
+  add_executable(snappy_uncompress_fuzzer "")
+  target_sources(snappy_uncompress_fuzzer
+    PRIVATE "snappy_uncompress_fuzzer.cc"
+  )
+  target_link_libraries(snappy_uncompress_fuzzer snappy)
+  set_target_properties(snappy_uncompress_fuzzer
+    PROPERTIES LINK_FLAGS "-fsanitize=fuzzer"
+  )
+endif(SNAPPY_FUZZING_BUILD)
+
+# Must be included before CMAKE_INSTALL_INCLUDEDIR is used.
 include(GNUInstallDirs)
-install(TARGETS snappy
-  EXPORT SnappyTargets
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
-install(
-  FILES
-    "${PROJECT_SOURCE_DIR}/snappy-c.h"
-    "${PROJECT_SOURCE_DIR}/snappy-sinksource.h"
-    "${PROJECT_SOURCE_DIR}/snappy.h"
-    "${PROJECT_BINARY_DIR}/snappy-stubs-public.h"
-  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)
 
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(
-    "${PROJECT_BINARY_DIR}/SnappyConfigVersion.cmake"
+if(SNAPPY_INSTALL)
+  install(TARGETS snappy
+    EXPORT SnappyTargets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  )
+  install(
+    FILES
+      "snappy-c.h"
+      "snappy-sinksource.h"
+      "snappy.h"
+      "${PROJECT_BINARY_DIR}/snappy-stubs-public.h"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+
+  include(CMakePackageConfigHelpers)
+  configure_package_config_file(
+    "cmake/${PROJECT_NAME}Config.cmake.in"
+    "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+  )
+  write_basic_package_version_file(
+    "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
     COMPATIBILITY SameMajorVersion
-)
-install(
-  EXPORT SnappyTargets
-  NAMESPACE Snappy::
-  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Snappy"
-)
-install(
-  FILES
-    "${PROJECT_SOURCE_DIR}/cmake/SnappyConfig.cmake"
-    "${PROJECT_BINARY_DIR}/SnappyConfigVersion.cmake"
-  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Snappy"
-)
+  )
+  install(
+    EXPORT SnappyTargets
+    NAMESPACE Snappy::
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+  )
+  install(
+    FILES
+      "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+      "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+  )
+endif(SNAPPY_INSTALL)