1 files changed, 565 insertions, 0 deletions
diff --git a/src/zstd/contrib/linux-kernel/test/UserlandTest.cpp b/src/zstd/contrib/linux-kernel/test/UserlandTest.cpp
new file mode 100644
index 00000000..03058382
--- /dev/null
+++ b/src/zstd/contrib/linux-kernel/test/UserlandTest.cpp
@@ -0,0 +1,565 @@
+extern "C" {
+#include <linux/zstd.h>
+}
+#include <gtest/gtest.h>
+#include <memory>
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+namespace {
+struct WorkspaceDeleter {
+  void *memory;
+
+  template <typename T> void operator()(T const *) { free(memory); }
+};
+
+std::unique_ptr<ZSTD_CCtx, WorkspaceDeleter>
+createCCtx(ZSTD_compressionParameters cParams) {
+  size_t const workspaceSize = ZSTD_CCtxWorkspaceBound(cParams);
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_CCtx, WorkspaceDeleter> cctx{
+      ZSTD_initCCtx(workspace, workspaceSize), WorkspaceDeleter{workspace}};
+  if (!cctx) {
+    throw std::runtime_error{"Bad cctx"};
+  }
+  return cctx;
+}
+
+std::unique_ptr<ZSTD_CCtx, WorkspaceDeleter>
+createCCtx(int level, unsigned long long estimatedSrcSize = 0,
+           size_t dictSize = 0) {
+  auto const cParams = ZSTD_getCParams(level, estimatedSrcSize, dictSize);
+  return createCCtx(cParams);
+}
+
+std::unique_ptr<ZSTD_DCtx, WorkspaceDeleter>
+createDCtx() {
+  size_t const workspaceSize = ZSTD_DCtxWorkspaceBound();
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_DCtx, WorkspaceDeleter> dctx{
+      ZSTD_initDCtx(workspace, workspaceSize), WorkspaceDeleter{workspace}};
+  if (!dctx) {
+    throw std::runtime_error{"Bad dctx"};
+  }
+  return dctx;
+}
+
+std::unique_ptr<ZSTD_CDict, WorkspaceDeleter>
+createCDict(std::string const& dict, ZSTD_parameters params) {
+  size_t const workspaceSize = ZSTD_CDictWorkspaceBound(params.cParams);
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_CDict, WorkspaceDeleter> cdict{
+      ZSTD_initCDict(dict.data(), dict.size(), params, workspace,
+                     workspaceSize),
+      WorkspaceDeleter{workspace}};
+  if (!cdict) {
+    throw std::runtime_error{"Bad cdict"};
+  }
+  return cdict;
+}
+
+std::unique_ptr<ZSTD_CDict, WorkspaceDeleter>
+createCDict(std::string const& dict, int level) {
+  auto const params = ZSTD_getParams(level, 0, dict.size());
+  return createCDict(dict, params);
+}
+
+std::unique_ptr<ZSTD_DDict, WorkspaceDeleter>
+createDDict(std::string const& dict) {
+  size_t const workspaceSize = ZSTD_DDictWorkspaceBound();
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_DDict, WorkspaceDeleter> ddict{
+      ZSTD_initDDict(dict.data(), dict.size(), workspace, workspaceSize),
+      WorkspaceDeleter{workspace}};
+  if (!ddict) {
+    throw std::runtime_error{"Bad ddict"};
+  }
+  return ddict;
+}
+
+std::unique_ptr<ZSTD_CStream, WorkspaceDeleter>
+createCStream(ZSTD_parameters params, unsigned long long pledgedSrcSize = 0) {
+  size_t const workspaceSize = ZSTD_CStreamWorkspaceBound(params.cParams);
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_CStream, WorkspaceDeleter> zcs{
+      ZSTD_initCStream(params, pledgedSrcSize, workspace, workspaceSize)};
+  if (!zcs) {
+    throw std::runtime_error{"bad cstream"};
+  }
+  return zcs;
+}
+
+std::unique_ptr<ZSTD_CStream, WorkspaceDeleter>
+createCStream(ZSTD_compressionParameters cParams, ZSTD_CDict const &cdict,
+              unsigned long long pledgedSrcSize = 0) {
+  size_t const workspaceSize = ZSTD_CStreamWorkspaceBound(cParams);
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_CStream, WorkspaceDeleter> zcs{
+      ZSTD_initCStream_usingCDict(&cdict, pledgedSrcSize, workspace,
+                                  workspaceSize)};
+  if (!zcs) {
+    throw std::runtime_error{"bad cstream"};
+  }
+  return zcs;
+}
+
+std::unique_ptr<ZSTD_CStream, WorkspaceDeleter>
+createCStream(int level, unsigned long long pledgedSrcSize = 0) {
+  auto const params = ZSTD_getParams(level, pledgedSrcSize, 0);
+  return createCStream(params, pledgedSrcSize);
+}
+
+std::unique_ptr<ZSTD_DStream, WorkspaceDeleter>
+createDStream(size_t maxWindowSize = (1ULL << ZSTD_WINDOWLOG_MAX),
+              ZSTD_DDict const *ddict = nullptr) {
+  size_t const workspaceSize = ZSTD_DStreamWorkspaceBound(maxWindowSize);
+  void *workspace = malloc(workspaceSize);
+  std::unique_ptr<ZSTD_DStream, WorkspaceDeleter> zds{
+      ddict == nullptr
+          ? ZSTD_initDStream(maxWindowSize, workspace, workspaceSize)
+          : ZSTD_initDStream_usingDDict(maxWindowSize, ddict, workspace,
+                                        workspaceSize)};
+  if (!zds) {
+    throw std::runtime_error{"bad dstream"};
+  }
+  return zds;
+}
+
+std::string compress(ZSTD_CCtx &cctx, std::string const &data,
+                     ZSTD_parameters params, std::string const &dict = "") {
+  std::string compressed;
+  compressed.resize(ZSTD_compressBound(data.size()));
+  size_t const rc =
+      dict.empty()
+          ? ZSTD_compressCCtx(&cctx, &compressed[0], compressed.size(),
+                              data.data(), data.size(), params)
+          : ZSTD_compress_usingDict(&cctx, &compressed[0], compressed.size(),
+                                    data.data(), data.size(), dict.data(),
+                                    dict.size(), params);
+  if (ZSTD_isError(rc)) {
+    throw std::runtime_error{"compression error"};
+  }
+  compressed.resize(rc);
+  return compressed;
+}
+
+std::string compress(ZSTD_CCtx& cctx, std::string const& data, int level, std::string const& dict = "") {
+  auto const params = ZSTD_getParams(level, 0, dict.size());
+  return compress(cctx, data, params, dict);
+}
+
+std::string decompress(ZSTD_DCtx& dctx, std::string const& compressed, size_t decompressedSize, std::string const& dict = "") {
+  std::string decompressed;
+  decompressed.resize(decompressedSize);
+  size_t const rc =
+      dict.empty()
+          ? ZSTD_decompressDCtx(&dctx, &decompressed[0], decompressed.size(),
+                                compressed.data(), compressed.size())
+          : ZSTD_decompress_usingDict(
+                &dctx, &decompressed[0], decompressed.size(), compressed.data(),
+                compressed.size(), dict.data(), dict.size());
+  if (ZSTD_isError(rc)) {
+    throw std::runtime_error{"decompression error"};
+  }
+  decompressed.resize(rc);
+  return decompressed;
+}
+
+std::string compress(ZSTD_CCtx& cctx, std::string const& data, ZSTD_CDict& cdict) {
+  std::string compressed;
+  compressed.resize(ZSTD_compressBound(data.size()));
+  size_t const rc =
+      ZSTD_compress_usingCDict(&cctx, &compressed[0], compressed.size(),
+                               data.data(), data.size(), &cdict);
+  if (ZSTD_isError(rc)) {
+    throw std::runtime_error{"compression error"};
+  }
+  compressed.resize(rc);
+  return compressed;
+}
+
+std::string decompress(ZSTD_DCtx& dctx, std::string const& compressed, size_t decompressedSize, ZSTD_DDict& ddict) {
+  std::string decompressed;
+  decompressed.resize(decompressedSize);
+  size_t const rc =
+      ZSTD_decompress_usingDDict(&dctx, &decompressed[0], decompressed.size(),
+                                 compressed.data(), compressed.size(), &ddict);
+  if (ZSTD_isError(rc)) {
+    throw std::runtime_error{"decompression error"};
+  }
+  decompressed.resize(rc);
+  return decompressed;
+}
+
+std::string compress(ZSTD_CStream& zcs, std::string const& data) {
+  std::string compressed;
+  compressed.resize(ZSTD_compressBound(data.size()));
+  ZSTD_inBuffer in = {data.data(), data.size(), 0};
+  ZSTD_outBuffer out = {&compressed[0], compressed.size(), 0};
+  while (in.pos != in.size) {
+    size_t const rc = ZSTD_compressStream(&zcs, &out, &in);
+    if (ZSTD_isError(rc)) {
+      throw std::runtime_error{"compress stream failed"};
+    }
+  }
+  size_t const rc = ZSTD_endStream(&zcs, &out);
+  if (rc != 0) {
+    throw std::runtime_error{"compress end failed"};
+  }
+  compressed.resize(out.pos);
+  return compressed;
+}
+
+std::string decompress(ZSTD_DStream &zds, std::string const &compressed,
+                       size_t decompressedSize) {
+  std::string decompressed;
+  decompressed.resize(decompressedSize);
+  ZSTD_inBuffer in = {compressed.data(), compressed.size(), 0};
+  ZSTD_outBuffer out = {&decompressed[0], decompressed.size(), 0};
+  while (in.pos != in.size) {
+    size_t const rc = ZSTD_decompressStream(&zds, &out, &in);
+    if (ZSTD_isError(rc)) {
+      throw std::runtime_error{"decompress stream failed"};
+    }
+  }
+  decompressed.resize(out.pos);
+  return decompressed;
+}
+
+std::string makeData(size_t size) {
+  std::string result;
+  result.reserve(size + 20);
+  while (result.size() < size) {
+    result += "Hello world";
+  }
+  return result;
+}
+
+std::string const kData = "Hello world";
+std::string const kPlainDict = makeData(10000);
+std::string const kZstdDict{
+    "\x37\xA4\x30\xEC\x99\x69\x58\x1C\x21\x10\xD8\x4A\x84\x01\xCC\xF3"
+    "\x3C\xCF\x9B\x25\xBB\xC9\x6E\xB2\x9B\xEC\x26\xAD\xCF\xDF\x4E\xCD"
+    "\xF3\x2C\x3A\x21\x84\x10\x42\x08\x21\x01\x33\xF1\x78\x3C\x1E\x8F"
+    "\xC7\xE3\xF1\x78\x3C\xCF\xF3\xBC\xF7\xD4\x42\x41\x41\x41\x41\x41"
+    "\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41"
+    "\x41\x41\x41\x41\xA1\x50\x28\x14\x0A\x85\x42\xA1\x50\x28\x14\x0A"
+    "\x85\xA2\x28\x8A\xA2\x28\x4A\x29\x7D\x74\xE1\xE1\xE1\xE1\xE1\xE1"
+    "\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xE1\xF1\x78\x3C"
+    "\x1E\x8F\xC7\xE3\xF1\x78\x9E\xE7\x79\xEF\x01\x01\x00\x00\x00\x04"
+    "\x00\x00\x00\x08\x00\x00\x00"
+    "0123456789",
+    161};
+}
+
+TEST(Block, CCtx) {
+  auto cctx = createCCtx(1);
+  auto const compressed = compress(*cctx, kData, 1);
+  auto dctx = createDCtx();
+  auto const decompressed = decompress(*dctx, compressed, kData.size());
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Block, NoContentSize) {
+  auto cctx = createCCtx(1);
+  auto const c = compress(*cctx, kData, 1);
+  auto const size = ZSTD_findDecompressedSize(c.data(), c.size());
+  EXPECT_EQ(ZSTD_CONTENTSIZE_UNKNOWN, size);
+}
+
+TEST(Block, ContentSize) {
+  auto cctx = createCCtx(1);
+  auto params = ZSTD_getParams(1, 0, 0);
+  params.fParams.contentSizeFlag = 1;
+  auto const c = compress(*cctx, kData, params);
+  auto const size = ZSTD_findDecompressedSize(c.data(), c.size());
+  EXPECT_EQ(kData.size(), size);
+}
+
+TEST(Block, CCtxLevelIncrease) {
+  std::string c;
+  auto cctx = createCCtx(22);
+  auto dctx = createDCtx();
+  for (int level = 1; level <= 22; ++level) {
+    auto compressed = compress(*cctx, kData, level);
+    auto const decompressed = decompress(*dctx, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+}
+
+TEST(Block, PlainDict) {
+  auto cctx = createCCtx(1);
+  auto const compressed = compress(*cctx, kData, 1, kPlainDict);
+  auto dctx = createDCtx();
+  EXPECT_ANY_THROW(decompress(*dctx, compressed, kData.size()));
+  auto const decompressed =
+      decompress(*dctx, compressed, kData.size(), kPlainDict);
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Block, ZstdDict) {
+  auto cctx = createCCtx(1);
+  auto const compressed = compress(*cctx, kData, 1, kZstdDict);
+  auto dctx = createDCtx();
+  EXPECT_ANY_THROW(decompress(*dctx, compressed, kData.size()));
+  auto const decompressed =
+      decompress(*dctx, compressed, kData.size(), kZstdDict);
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Block, PreprocessedPlainDict) {
+  auto cctx = createCCtx(1);
+  auto const cdict = createCDict(kPlainDict, 1);
+  auto const compressed = compress(*cctx, kData, *cdict);
+  auto dctx = createDCtx();
+  auto const ddict = createDDict(kPlainDict);
+  EXPECT_ANY_THROW(decompress(*dctx, compressed, kData.size()));
+  auto const decompressed =
+      decompress(*dctx, compressed, kData.size(), *ddict);
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Block, PreprocessedZstdDict) {
+  auto cctx = createCCtx(1);
+  auto const cdict = createCDict(kZstdDict, 1);
+  auto const compressed = compress(*cctx, kData, *cdict);
+  auto dctx = createDCtx();
+  auto const ddict = createDDict(kZstdDict);
+  EXPECT_ANY_THROW(decompress(*dctx, compressed, kData.size()));
+  auto const decompressed =
+      decompress(*dctx, compressed, kData.size(), *ddict);
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Block, ReinitializeCCtx) {
+  auto cctx = createCCtx(1);
+  {
+    auto const compressed = compress(*cctx, kData, 1);
+    auto dctx = createDCtx();
+    auto const decompressed = decompress(*dctx, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+  // Create the cctx with the same memory
+  auto d = cctx.get_deleter();
+  auto raw = cctx.release();
+  auto params = ZSTD_getParams(1, 0, 0);
+  cctx.reset(
+      ZSTD_initCCtx(d.memory, ZSTD_CCtxWorkspaceBound(params.cParams)));
+  // Repeat
+  {
+    auto const compressed = compress(*cctx, kData, 1);
+    auto dctx = createDCtx();
+    auto const decompressed = decompress(*dctx, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+}
+
+TEST(Block, ReinitializeDCtx) {
+  auto dctx = createDCtx();
+  {
+    auto cctx = createCCtx(1);
+    auto const compressed = compress(*cctx, kData, 1);
+    auto const decompressed = decompress(*dctx, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+  // Create the cctx with the same memory
+  auto d = dctx.get_deleter();
+  auto raw = dctx.release();
+  dctx.reset(ZSTD_initDCtx(d.memory, ZSTD_DCtxWorkspaceBound()));
+  // Repeat
+  {
+    auto cctx = createCCtx(1);
+    auto const compressed = compress(*cctx, kData, 1);
+    auto dctx = createDCtx();
+    auto const decompressed = decompress(*dctx, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+}
+
+TEST(Stream, Basic) {
+  auto zcs = createCStream(1);
+  auto const compressed = compress(*zcs, kData);
+  auto zds = createDStream();
+  auto const decompressed = decompress(*zds, compressed, kData.size());
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Stream, PlainDict) {
+  auto params = ZSTD_getParams(1, kData.size(), kPlainDict.size());
+  params.cParams.windowLog = 17;
+  auto cdict = createCDict(kPlainDict, params);
+  auto zcs = createCStream(params.cParams, *cdict, kData.size());
+  auto const compressed = compress(*zcs, kData);
+  auto const contentSize =
+      ZSTD_findDecompressedSize(compressed.data(), compressed.size());
+  EXPECT_ANY_THROW(decompress(*createDStream(), compressed, kData.size()));
+  auto ddict = createDDict(kPlainDict);
+  auto zds = createDStream(1 << 17, ddict.get());
+  auto const decompressed = decompress(*zds, compressed, kData.size());
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Stream, ZstdDict) {
+  auto params = ZSTD_getParams(1, 0, 0);
+  params.cParams.windowLog = 17;
+  auto cdict = createCDict(kZstdDict, 1);
+  auto zcs = createCStream(params.cParams, *cdict);
+  auto const compressed = compress(*zcs, kData);
+  EXPECT_ANY_THROW(decompress(*createDStream(), compressed, kData.size()));
+  auto ddict = createDDict(kZstdDict);
+  auto zds = createDStream(1 << 17, ddict.get());
+  auto const decompressed = decompress(*zds, compressed, kData.size());
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Stream, ResetCStream) {
+  auto zcs = createCStream(1);
+  auto zds = createDStream();
+  {
+    auto const compressed = compress(*zcs, kData);
+    auto const decompressed = decompress(*zds, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+  {
+    ZSTD_resetCStream(zcs.get(), 0);
+    auto const compressed = compress(*zcs, kData);
+    auto const decompressed = decompress(*zds, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+}
+
+TEST(Stream, ResetDStream) {
+  auto zcs = createCStream(1);
+  auto zds = createDStream();
+  auto const compressed = compress(*zcs, kData);
+  EXPECT_ANY_THROW(decompress(*zds, kData, kData.size()));
+  EXPECT_ANY_THROW(decompress(*zds, compressed, kData.size()));
+  ZSTD_resetDStream(zds.get());
+  auto const decompressed = decompress(*zds, compressed, kData.size());
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Stream, Flush) {
+  auto zcs = createCStream(1);
+  auto zds = createDStream();
+  std::string compressed;
+  {
+    compressed.resize(ZSTD_compressBound(kData.size()));
+    ZSTD_inBuffer in = {kData.data(), kData.size(), 0};
+    ZSTD_outBuffer out = {&compressed[0], compressed.size(), 0};
+    while (in.pos != in.size) {
+      size_t const rc = ZSTD_compressStream(zcs.get(), &out, &in);
+      if (ZSTD_isError(rc)) {
+        throw std::runtime_error{"compress stream failed"};
+      }
+    }
+    EXPECT_EQ(0, out.pos);
+    size_t const rc = ZSTD_flushStream(zcs.get(), &out);
+    if (rc != 0) {
+      throw std::runtime_error{"compress end failed"};
+    }
+    compressed.resize(out.pos);
+    EXPECT_LT(0, out.pos);
+  }
+  std::string decompressed;
+  {
+    decompressed.resize(kData.size());
+    ZSTD_inBuffer in = {compressed.data(), compressed.size(), 0};
+    ZSTD_outBuffer out = {&decompressed[0], decompressed.size(), 0};
+    while (in.pos != in.size) {
+      size_t const rc = ZSTD_decompressStream(zds.get(), &out, &in);
+      if (ZSTD_isError(rc)) {
+        throw std::runtime_error{"decompress stream failed"};
+      }
+    }
+  }
+  EXPECT_EQ(kData, decompressed);
+}
+
+TEST(Stream, DStreamLevelIncrease) {
+  auto zds = createDStream();
+  for (int level = 1; level <= 22; ++level) {
+    auto zcs = createCStream(level);
+    auto compressed = compress(*zcs, kData);
+    ZSTD_resetDStream(zds.get());
+    auto const decompressed = decompress(*zds, compressed, kData.size());
+    EXPECT_EQ(kData, decompressed);
+  }
+}
+
+#define TEST_SYMBOL(symbol)                                                    \
+  do {                                                                         \
+    extern void *__##symbol;                                                   \
+    EXPECT_NE((void *)0, __##symbol);                                          \
+  } while (0)
+
+TEST(API, Symbols) {
+  TEST_SYMBOL(ZSTD_CCtxWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initCCtx);
+  TEST_SYMBOL(ZSTD_compressCCtx);
+  TEST_SYMBOL(ZSTD_compress_usingDict);
+  TEST_SYMBOL(ZSTD_DCtxWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initDCtx);
+  TEST_SYMBOL(ZSTD_decompressDCtx);
+  TEST_SYMBOL(ZSTD_decompress_usingDict);
+
+  TEST_SYMBOL(ZSTD_CDictWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initCDict);
+  TEST_SYMBOL(ZSTD_compress_usingCDict);
+  TEST_SYMBOL(ZSTD_DDictWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initDDict);
+  TEST_SYMBOL(ZSTD_decompress_usingDDict);
+
+  TEST_SYMBOL(ZSTD_CStreamWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initCStream);
+  TEST_SYMBOL(ZSTD_initCStream_usingCDict);
+  TEST_SYMBOL(ZSTD_resetCStream);
+  TEST_SYMBOL(ZSTD_compressStream);
+  TEST_SYMBOL(ZSTD_flushStream);
+  TEST_SYMBOL(ZSTD_endStream);
+  TEST_SYMBOL(ZSTD_CStreamInSize);
+  TEST_SYMBOL(ZSTD_CStreamOutSize);
+  TEST_SYMBOL(ZSTD_DStreamWorkspaceBound);
+  TEST_SYMBOL(ZSTD_initDStream);
+  TEST_SYMBOL(ZSTD_initDStream_usingDDict);
+  TEST_SYMBOL(ZSTD_resetDStream);
+  TEST_SYMBOL(ZSTD_decompressStream);
+  TEST_SYMBOL(ZSTD_DStreamInSize);
+  TEST_SYMBOL(ZSTD_DStreamOutSize);
+
+  TEST_SYMBOL(ZSTD_findFrameCompressedSize);
+  TEST_SYMBOL(ZSTD_getFrameContentSize);
+  TEST_SYMBOL(ZSTD_findDecompressedSize);
+
+  TEST_SYMBOL(ZSTD_getCParams);
+  TEST_SYMBOL(ZSTD_getParams);
+  TEST_SYMBOL(ZSTD_checkCParams);
+  TEST_SYMBOL(ZSTD_adjustCParams);
+
+  TEST_SYMBOL(ZSTD_isFrame);
+  TEST_SYMBOL(ZSTD_getDictID_fromDict);
+  TEST_SYMBOL(ZSTD_getDictID_fromDDict);
+  TEST_SYMBOL(ZSTD_getDictID_fromFrame);
+
+  TEST_SYMBOL(ZSTD_compressBegin);
+  TEST_SYMBOL(ZSTD_compressBegin_usingDict);
+  TEST_SYMBOL(ZSTD_compressBegin_advanced);
+  TEST_SYMBOL(ZSTD_copyCCtx);
+  TEST_SYMBOL(ZSTD_compressBegin_usingCDict);
+  TEST_SYMBOL(ZSTD_compressContinue);
+  TEST_SYMBOL(ZSTD_compressEnd);
+  TEST_SYMBOL(ZSTD_getFrameParams);
+  TEST_SYMBOL(ZSTD_decompressBegin);
+  TEST_SYMBOL(ZSTD_decompressBegin_usingDict);
+  TEST_SYMBOL(ZSTD_copyDCtx);
+  TEST_SYMBOL(ZSTD_nextSrcSizeToDecompress);
+  TEST_SYMBOL(ZSTD_decompressContinue);
+  TEST_SYMBOL(ZSTD_nextInputType);
+
+  TEST_SYMBOL(ZSTD_getBlockSizeMax);
+  TEST_SYMBOL(ZSTD_compressBlock);
+  TEST_SYMBOL(ZSTD_decompressBlock);
+  TEST_SYMBOL(ZSTD_insertBlock);
+}