lz4-native-ruby 0.1.1 → 1.0.1

data/{vendor/lz4/lib → ext/lz4_native}/lz4frame.h

@@ -1,7 +1,8 @@
 /*
    LZ4F - LZ4-Frame library
    Header File
-   Copyright (C) 2011-2020, Yann Collet.
+   Copyright (c) Yann Collet. All rights reserved.
+
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without
@@ -289,6 +290,9 @@ LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
 /* Size in bytes of the content checksum. */
 #define LZ4F_CONTENT_CHECKSUM_SIZE 4
 
+/* Size in bytes of the endmark. */
+#define LZ4F_ENDMARK_SIZE 4
+
 /*! LZ4F_compressBegin() :
  *  will write the frame header into dstBuffer.
  *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
@@ -462,41 +466,52 @@ LZ4F_getFrameInfo(LZ4F_dctx* dctx,
                   LZ4F_frameInfo_t* frameInfoPtr,
             const void* srcBuffer, size_t* srcSizePtr);
 
-/*! LZ4F_decompress() :
- *  Call this function repetitively to regenerate data compressed in `srcBuffer`.
- *
- *  The function requires a valid dctx state.
- *  It will read up to *srcSizePtr bytes from srcBuffer,
- *  and decompress data into dstBuffer, of capacity *dstSizePtr.
+/**
+ * @brief Incrementally decompresses an LZ4 frame into user-provided buffers.
  *
- *  The nb of bytes consumed from srcBuffer will be written into *srcSizePtr (necessarily <= original value).
- *  The nb of bytes decompressed into dstBuffer will be written into *dstSizePtr (necessarily <= original value).
+ * Call repeatedly until the return value is 0 (frame fully decoded) or an error is reported.
+ * On each call, the function consumes up to *srcSizePtr bytes from @p srcBuffer and
+ * produces up to *dstSizePtr bytes into @p dstBuffer. It updates both size pointers with
+ * the actual number of bytes consumed/produced. There is no separate flush step.
  *
- *  The function does not necessarily read all input bytes, so always check value in *srcSizePtr.
- *  Unconsumed source data must be presented again in subsequent invocations.
+ * Typical loop:
+ *  - Provide whatever input you have and an available output buffer.
+ *  - Read how much input was consumed and how much output was produced.
+ *  - Use the returned value as a hint for how many source bytes are ideal next time.
  *
- * `dstBuffer` can freely change between each consecutive function invocation.
- * `dstBuffer` content will be overwritten.
+ * @param[in]      dctx        A valid decompression context created by LZ4F_createDecompressionContext().
+ * @param[out]     dstBuffer   Destination buffer for decompressed bytes. May change between calls.
+ * @param[in,out]  dstSizePtr  In: capacity of @p dstBuffer in bytes. Out: number of bytes written (<= input value).
+ * @param[in]      srcBuffer   Source buffer containing (more) compressed data. May point to the middle of a larger buffer.
+ * @param[in,out]  srcSizePtr  In: number of available bytes in @p srcBuffer. Out: number of bytes consumed (<= input value).
+ * @param[in]      optionsPtr  Optional decompression options; pass NULL for defaults.
  *
- *  Note: if `LZ4F_getFrameInfo()` is called before `LZ4F_decompress()`, srcBuffer must be updated to reflect
- *  the number of bytes consumed after reading the frame header. Failure to update srcBuffer before calling
- *  `LZ4F_decompress()` will cause decompression failure or, even worse, successful but incorrect decompression.
- *  See the `LZ4F_getFrameInfo()` docs for details.
+ * @return See @retval cases.
+ * @retval >0  Hint (in bytes) for how many source bytes are ideal to provide on the next call.
+ *             This also indicates the current frame is not yet complete: the decompressor
+ *             expects more input, or may require additional output space to make progress. 
+ *             User can always pass any amount of input; this value is only a performance hint.
+ * @retval 0   The current frame is fully decoded. If *srcSizePtr is less than the provided value, 
+ *             the unconsumed tail is the start of another frame (if any).
+ * @retval error  An error code; test with LZ4F_isError(ret). After an error, dctx is not
+ *                resumable: call LZ4F_resetDecompressionContext() before reusing it.
  *
- * @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call.
- *  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
- *  Respecting the hint provides some small speed benefit, because it skips intermediate buffers.
- *  This is just a hint though, it's always possible to provide any srcSize.
+ * @pre  @p dctx is a valid state created by LZ4F_createDecompressionContext().
+ * @post *srcSizePtr and *dstSizePtr are updated with the actual bytes consumed/produced.
+ *       @p dstBuffer contents in [0, *dstSizePtr) are valid decompressed data.
  *
- *  When a frame is fully decoded, @return will be 0 (no more data expected).
- *  When provided with more bytes than necessary to decode a frame,
- *  LZ4F_decompress() will stop reading exactly at end of current frame, and @return 0.
+ * @note  The function may not consume all provided input on each call. Always check *srcSizePtr.
+ *        Present any unconsumed source bytes again on the next call.
+ * @note  @p dstBuffer content is overwritten; it does not need to be stable across calls.
+ * @note  After finishing a frame (return==0), you may immediately start feeding the next frame
+ *        into the same @p dctx (optionally, one can use LZ4F_resetDecompressionContext()).
  *
- *  If decompression failed, @return is an error code, which can be tested using LZ4F_isError().
- *  After a decompression error, the `dctx` context is not resumable.
- *  Use LZ4F_resetDecompressionContext() to return to clean state.
+ * @warning If you called LZ4F_getFrameInfo() beforehand, you must advance @p srcBuffer and
+ *          decrease *srcSizePtr by the number of bytes it consumed (the frame header). Failing
+ *          to do so can cause decompression failure or, worse, silent corruption.
  *
- *  After a frame is fully decoded, dctx can be used again to decompress another frame.
+ * @see LZ4F_getFrameInfo(), LZ4F_isError(), LZ4F_resetDecompressionContext(),
+ *      LZ4F_createDecompressionContext(), LZ4F_freeDecompressionContext()
  */
 LZ4FLIB_API size_t
 LZ4F_decompress(LZ4F_dctx* dctx,
@@ -743,6 +758,11 @@ LZ4FLIB_STATIC_API LZ4F_cctx* LZ4F_createCompressionContext_advanced(LZ4F_Custom
 LZ4FLIB_STATIC_API LZ4F_dctx* LZ4F_createDecompressionContext_advanced(LZ4F_CustomMem customMem, unsigned version);
 LZ4FLIB_STATIC_API LZ4F_CDict* LZ4F_createCDict_advanced(LZ4F_CustomMem customMem, const void* dictBuffer, size_t dictSize);
 
+/*! Context size inspection : v1.10.1+
+ *  These functions return the total memory footprint of the provided context.
+ */
+LZ4FLIB_STATIC_API size_t LZ4F_cctx_size(const LZ4F_cctx* cctx);
+LZ4FLIB_STATIC_API size_t LZ4F_dctx_size(const LZ4F_dctx* dctx);
 
 #if defined (__cplusplus)
 }

data/{vendor/lz4/lib → ext/lz4_native}/lz4frame_static.h

@@ -1,7 +1,7 @@
 /*
    LZ4 auto-framing library
    Header File for static linking only
-   Copyright (C) 2011-2020, Yann Collet.
+   Copyright (c) Yann Collet. All rights reserved.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 

data/{vendor/lz4/lib → ext/lz4_native}/lz4hc.c

@@ -1,6 +1,6 @@
 /*
     LZ4 HC - High Compression Mode of LZ4
-    Copyright (C) 2011-2020, Yann Collet.
+    Copyright (c) Yann Collet. All rights reserved.
 
     BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -262,6 +262,30 @@ static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
 /**************************************
 *  Encode
 **************************************/
+#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 2)
+# define RAWLOG(...) fprintf(stderr, __VA_ARGS__)
+void LZ4HC_hexOut(const void* src, size_t len)
+{
+    const BYTE* p = (const BYTE*)src;
+    size_t n;
+    for (n=0; n<len; n++) {
+        RAWLOG("%02X ", p[n]);
+    }
+    RAWLOG(" \n");
+}
+
+# define HEX_CMP(_lev, _ptr, _ref, _len) \
+    if (LZ4_DEBUG >= _lev) {            \
+        RAWLOG("match bytes: ");        \
+        LZ4HC_hexOut(_ptr, _len);       \
+        RAWLOG("ref bytes: ");          \
+        LZ4HC_hexOut(_ref, _len);       \
+    }
+
+#else
+# define HEX_CMP(l,p,r,_l)
+#endif
+
 /* LZ4HC_encodeSequence() :
  * @return : 0 if ok,
  *           1 if buffer issue detected */
@@ -278,47 +302,49 @@ LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
 #define op      (*_op)
 #define anchor  (*_anchor)
 
-    size_t length;
     BYTE* const token = op++;
 
 #if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)
     static const BYTE* start = NULL;
     static U32 totalCost = 0;
-    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);
+    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start); /* only works for single segment */
     U32 const ll = (U32)(ip - anchor);
     U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;
     U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;
     U32 const cost = 1 + llAdd + ll + 2 + mlAdd;
     if (start==NULL) start = anchor;  /* only works for single segment */
-    /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */
     DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5i, cost:%4u + %5u",
                 pos,
                 (U32)(ip - anchor), matchLength, offset,
                 cost, totalCost);
+# if 1 /* only works on single segment data */
+    HEX_CMP(7, ip, ip-offset, matchLength);
+# endif
     totalCost += cost;
 #endif
 
     /* Encode Literal length */
-    length = (size_t)(ip - anchor);
-    LZ4_STATIC_ASSERT(notLimited == 0);
-    /* Check output limit */
-    if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {
-        DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",
-                (int)length, (int)(oend - op));
-        return 1;
-    }
-    if (length >= RUN_MASK) {
-        size_t len = length - RUN_MASK;
-        *token = (RUN_MASK << ML_BITS);
-        for(; len >= 255 ; len -= 255) *op++ = 255;
-        *op++ = (BYTE)len;
-    } else {
-        *token = (BYTE)(length << ML_BITS);
-    }
+    {   size_t litLen = (size_t)(ip - anchor);
+        LZ4_STATIC_ASSERT(notLimited == 0);
+        /* Check output limit */
+        if (limit && ((op + (litLen / 255) + litLen + (2 + 1 + LASTLITERALS)) > oend)) {
+            DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",
+                    (int)litLen, (int)(oend - op));
+            return 1;
+        }
+        if (litLen >= RUN_MASK) {
+            size_t len = litLen - RUN_MASK;
+            *token = (RUN_MASK << ML_BITS);
+            for(; len >= 255 ; len -= 255) *op++ = 255;
+            *op++ = (BYTE)len;
+        } else {
+            *token = (BYTE)(litLen << ML_BITS);
+        }
 
-    /* Copy Literals */
-    LZ4_wildCopy8(op, anchor, op + length);
-    op += length;
+        /* Copy Literals */
+        LZ4_wildCopy8(op, anchor, op + litLen);
+        op += litLen;
+    }
 
     /* Encode Offset */
     assert(offset <= LZ4_DISTANCE_MAX );
@@ -327,20 +353,20 @@ LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
 
     /* Encode MatchLength */
     assert(matchLength >= MINMATCH);
-    length = (size_t)matchLength - MINMATCH;
-    if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {
-        DEBUGLOG(6, "Not enough room to write match length");
-        return 1;   /* Check output limit */
-    }
-    if (length >= ML_MASK) {
-        *token += ML_MASK;
-        length -= ML_MASK;
-        for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }
-        if (length >= 255) { length -= 255; *op++ = 255; }
-        *op++ = (BYTE)length;
-    } else {
-        *token += (BYTE)(length);
-    }
+    {   size_t mlCode = (size_t)matchLength - MINMATCH;
+        if (limit && (op + (mlCode / 255) + (1 + LASTLITERALS) > oend)) {
+            DEBUGLOG(6, "Not enough room to write match length");
+            return 1;   /* Check output limit */
+        }
+        if (mlCode >= ML_MASK) {
+            *token += ML_MASK;
+            mlCode -= ML_MASK;
+            for(; mlCode >= 510 ; mlCode -= 510) { *op++ = 255; *op++ = 255; }
+            if (mlCode >= 255) { mlCode -= 255; *op++ = 255; }
+            *op++ = (BYTE)mlCode;
+        } else {
+            *token += (BYTE)(mlCode);
+    }   }
 
     /* Prepare next loop */
     ip += matchLength;
@@ -519,6 +545,12 @@ static LZ4MID_searchIntoDict_f select_searchDict_function(const LZ4HC_CCtx_inter
     return LZ4MID_searchHCDict;
 }
 
+/* preconditions:
+ * - *srcSizePtr within [1, LZ4_MAX_INPUT_SIZE]
+ * - src is valid
+ * - maxOutputSize >= 1
+ * - dst is valid
+ */
 static int LZ4MID_compress (
     LZ4HC_CCtx_internal* const ctx,
     const char* const src,
@@ -550,18 +582,16 @@ static int LZ4MID_compress (
     unsigned matchLength;
     unsigned matchDistance;
 
-    /* input sanitization */
     DEBUGLOG(5, "LZ4MID_compress (%i bytes)", *srcSizePtr);
+
+    /* preconditions verifications */
     if (dict == usingDictCtxHc) DEBUGLOG(5, "usingDictCtxHc");
-    assert(*srcSizePtr >= 0);
-    if (*srcSizePtr) assert(src != NULL);
-    if (maxOutputSize) assert(dst != NULL);
-    if (*srcSizePtr < 0) return 0;  /* invalid */
-    if (maxOutputSize < 0) return 0; /* invalid */
-    if (*srcSizePtr > LZ4_MAX_INPUT_SIZE) {
-        /* forbidden: no input is allowed to be that large */
-        return 0;
-    }
+    assert(*srcSizePtr > 0);
+    assert(*srcSizePtr <= LZ4_MAX_INPUT_SIZE);
+    assert(src != NULL);
+    assert(maxOutputSize >= 1);
+    assert(dst != NULL);
+
     if (limit == fillOutput) oend -= LASTLITERALS;  /* Hack for support LZ4 format restriction */
     if (*srcSizePtr < LZ4_minLength)
         goto _lz4mid_last_literals;  /* Input too small, no compression (all literals) */
@@ -940,6 +970,7 @@ LZ4HC_InsertAndGetWiderMatch (
                         offset = (int)(ipIndex - matchIndex);
                         sBack = back;
                         DEBUGLOG(7, "Found match of len=%i within prefix, offset=%i, back=%i", longest, offset, -back);
+                        HEX_CMP(7, ip + back, ip + back - offset, (size_t)matchLength);
             }   }   }
         } else {   /* lowestMatchIndex <= matchIndex < dictLimit : within Ext Dict */
             const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx);
@@ -959,6 +990,7 @@ LZ4HC_InsertAndGetWiderMatch (
                     offset = (int)(ipIndex - matchIndex);
                     sBack = back;
                     DEBUGLOG(7, "Found match of len=%i within dict, offset=%i, back=%i", longest, offset, -back);
+                    HEX_CMP(7, ip + back, matchPtr + back, (size_t)matchLength);
         }   }   }
 
         if (chainSwap && matchLength==longest) {   /* better match => select a better chain */
@@ -1118,10 +1150,16 @@ LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4,   /* Index table wi
 }
 
 
+/* preconditions:
+ * - *srcSizePtr within [1, LZ4_MAX_INPUT_SIZE]
+ * - src is valid
+ * - maxOutputSize >= 1
+ * - dst is valid
+ */
 LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
     LZ4HC_CCtx_internal* const ctx,
-    const char* const source,
-    char* const dest,
+    const char* const src,
+    char* const dst,
     int* srcSizePtr,
     int const maxOutputSize,
     int maxNbAttempts,
@@ -1132,14 +1170,14 @@ LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
     const int inputSize = *srcSizePtr;
     const int patternAnalysis = (maxNbAttempts > 128);   /* levels 9+ */
 
-    const BYTE* ip = (const BYTE*) source;
+    const BYTE* ip = (const BYTE*)src;
     const BYTE* anchor = ip;
     const BYTE* const iend = ip + inputSize;
     const BYTE* const mflimit = iend - MFLIMIT;
     const BYTE* const matchlimit = (iend - LASTLITERALS);
 
-    BYTE* optr = (BYTE*) dest;
-    BYTE* op = (BYTE*) dest;
+    BYTE* optr = (BYTE*) dst;
+    BYTE* op = (BYTE*) dst;
     BYTE* oend = op + maxOutputSize;
 
     const BYTE* start0;
@@ -1150,6 +1188,13 @@ LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
 
     /* init */
     DEBUGLOG(5, "LZ4HC_compress_hashChain (dict?=>%i)", dict);
+
+    /* preconditions verifications */
+    assert(*srcSizePtr >= 1);
+    assert(src != NULL);
+    assert(maxOutputSize >= 1);
+    assert(dst != NULL);
+
     *srcSizePtr = 0;
     if (limit == fillOutput) oend -= LASTLITERALS;                  /* Hack for support LZ4 format restriction */
     if (inputSize < LZ4_minLength) goto _last_literals;             /* Input too small, no compression (all literals) */
@@ -1334,8 +1379,8 @@ _last_literals:
     }
 
     /* End */
-    *srcSizePtr = (int) (((const char*)ip) - source);
-    return (int) (((char*)op)-dest);
+    *srcSizePtr = (int) (((const char*)ip) - src);
+    return (int) (((char*)op)-dst);
 
 _dest_overflow:
     if (limit == fillOutput) {
@@ -1370,7 +1415,7 @@ static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx,
     const dictCtx_directive dict,
     const HCfavor_e favorDecSpeed);
 
-LZ4_FORCE_INLINE int
+static int
 LZ4HC_compress_generic_internal (
             LZ4HC_CCtx_internal* const ctx,
             const char* const src,
@@ -1382,11 +1427,15 @@ LZ4HC_compress_generic_internal (
             const dictCtx_directive dict
             )
 {
-    DEBUGLOG(5, "LZ4HC_compress_generic_internal(src=%p, srcSize=%d)",
-                src, *srcSizePtr);
+    DEBUGLOG(5, "LZ4HC_compress_generic_internal(src=%p, srcSize=%d, dstCapacity=%d)",
+                src, *srcSizePtr, dstCapacity);
 
-    if (limit == fillOutput && dstCapacity < 1) return 0;   /* Impossible to store anything */
+    /* input sanitization */
     if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;  /* Unsupported input size (too large or negative) */
+    if (dstCapacity < 1) return 0;   /* Invalid: impossible to store anything */
+    assert(dst); /* since dstCapacity >= 1, dst must be valid */
+    if (*srcSizePtr == 0) { *dst = 0; return 1; }
+    assert(src != NULL); /* since *srcSizePtr >= 1, src must be valid */
 
     ctx->end += *srcSizePtr;
     {   cParams_t const cParam = LZ4HC_getCLevelParams(cLevel);
@@ -1820,6 +1869,13 @@ LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx,
 }
 
 
+
+/* preconditions:
+ * - *srcSizePtr within [1, LZ4_MAX_INPUT_SIZE]
+ * - src is valid
+ * - maxOutputSize >= 1
+ * - dst is valid
+ */
 static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
                                     const char* const source,
                                     char* dst,
@@ -1837,7 +1893,7 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
 #if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
     LZ4HC_optimal_t* const opt = (LZ4HC_optimal_t*)ALLOC(sizeof(LZ4HC_optimal_t) * (LZ4_OPT_NUM + TRAILING_LITERALS));
 #else
-    LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS];   /* ~64 KB, which is a bit large for stack... */
+    LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS];   /* ~64 KB, which can be a bit large for some stacks... */
 #endif
 
     const BYTE* ip = (const BYTE*) source;
@@ -1852,10 +1908,17 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
     int ovoff = 0;
 
     /* init */
+    DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity);
 #if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
     if (opt == NULL) goto _return_label;
 #endif
-    DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity);
+
+    /* preconditions verifications */
+    assert(dstCapacity > 0);
+    assert(dst != NULL);
+    assert(*srcSizePtr > 0);
+    assert(source != NULL);
+
     *srcSizePtr = 0;
     if (limit == fillOutput) oend -= LASTLITERALS;   /* Hack for support LZ4 format restriction */
     if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1;

data/{vendor/lz4/lib → ext/lz4_native}/lz4hc.h

@@ -1,7 +1,7 @@
 /*
    LZ4 HC - High Compression Mode of LZ4
    Header File
-   Copyright (C) 2011-2020, Yann Collet.
+   Copyright (c) Yann Collet. All rights reserved.
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without

data/lib/lz4_native/version.rb

@@ -0,0 +1,3 @@
+module LZ4Native
+  VERSION = "1.0.1"
+end

data/lib/lz4_native.rb

@@ -0,0 +1,47 @@
+require "lz4_native/version"
+require "lz4_native/lz4_native" # C extension
+
+module LZ4Native
+  class Error < StandardError; end
+  class CompressionError < Error; end
+  class DecompressionError < Error; end
+  class FrameError < Error; end
+
+  # Simple block compression using default LZ4
+  # @param data [String] Data to compress
+  # @return [String] Compressed data
+  def self.compress(data)
+    LZ4.compress_default(data)
+  end
+
+  # Simple block decompression
+  # @param data [String] Compressed data
+  # @param max_size [Integer] Maximum expected decompressed size
+  # @return [String] Decompressed data
+  def self.decompress(data, max_size)
+    LZ4.decompress_safe(data, max_size)
+  end
+
+  # High compression mode
+  # @param data [String] Data to compress
+  # @param level [Integer] Compression level (1-12, default 9)
+  # @return [String] Compressed data
+  def self.compress_hc(data, level = 9)
+    LZ4HC.compress(data, level)
+  end
+
+  # Frame compression (self-contained format)
+  # @param data [String] Data to compress
+  # @param options [Hash] Frame compression options
+  # @return [String] Compressed frame
+  def self.compress_frame(data, options = {})
+    LZ4Frame.compress_frame(data, options)
+  end
+
+  # Frame decompression
+  # @param data [String] Compressed frame data
+  # @return [String] Decompressed data
+  def self.decompress_frame(data)
+    LZ4Frame.decompress_frame(data)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "lz4_native"
+
+require "minitest/autorun"

data/test/test_lz4_basic.rb

@@ -0,0 +1,100 @@
+require "test_helper"
+
+class TestLZ4Basic < Minitest::Test
+  def setup
+    @test_data = "Hello, World! " * 100
+    @small_data = "test"
+    @large_data = "A" * 100000
+  end
+
+  def test_version_number
+    version = LZ4Native::LZ4.version_number
+    assert version.is_a?(Integer)
+    assert version > 0
+  end
+
+  def test_version_string
+    version = LZ4Native::LZ4.version_string
+    assert version.is_a?(String)
+    assert version.length > 0
+  end
+
+  def test_compress_bound
+    bound = LZ4Native::LZ4.compress_bound(1000)
+    assert bound.is_a?(Integer)
+    assert bound > 1000
+  end
+
+  def test_compress_decompress_default
+    compressed = LZ4Native::LZ4.compress_default(@test_data)
+    assert compressed.is_a?(String)
+    assert compressed.bytesize < @test_data.bytesize
+    assert compressed.bytesize > 0
+
+    decompressed = LZ4Native::LZ4.decompress_safe(compressed, @test_data.bytesize * 2)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_compress_decompress_small_data
+    compressed = LZ4Native::LZ4.compress_default(@small_data)
+    decompressed = LZ4Native::LZ4.decompress_safe(compressed, @small_data.bytesize * 2)
+    assert_equal @small_data, decompressed
+  end
+
+  def test_compress_decompress_large_data
+    compressed = LZ4Native::LZ4.compress_default(@large_data)
+    assert compressed.bytesize < @large_data.bytesize
+
+    decompressed = LZ4Native::LZ4.decompress_safe(compressed, @large_data.bytesize * 2)
+    assert_equal @large_data, decompressed
+  end
+
+  def test_compress_fast
+    accelerations = [1, 5, 10]
+    accelerations.each do |accel|
+      compressed = LZ4Native::LZ4.compress_fast(@test_data, accel)
+      assert compressed.is_a?(String)
+      assert compressed.bytesize > 0
+
+      decompressed = LZ4Native::LZ4.decompress_safe(compressed, @test_data.bytesize * 2)
+      assert_equal @test_data, decompressed
+    end
+  end
+
+  def test_decompress_with_exact_size
+    compressed = LZ4Native::LZ4.compress_default(@test_data)
+    decompressed = LZ4Native::LZ4.decompress_safe(compressed, @test_data.bytesize)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_decompress_with_insufficient_size
+    compressed = LZ4Native::LZ4.compress_default(@test_data)
+    assert_raises(LZ4Native::DecompressionError) do
+      LZ4Native::LZ4.decompress_safe(compressed, 10)
+    end
+  end
+
+  def test_decompress_corrupt_data
+    corrupt_data = "this is not compressed data"
+    assert_raises(LZ4Native::DecompressionError) do
+      LZ4Native::LZ4.decompress_safe(corrupt_data, 1000)
+    end
+  end
+
+  def test_high_level_compress
+    compressed = LZ4Native.compress(@test_data)
+    assert compressed.is_a?(String)
+    assert compressed.bytesize > 0
+  end
+
+  def test_high_level_decompress
+    compressed = LZ4Native.compress(@test_data)
+    decompressed = LZ4Native.decompress(compressed, @test_data.bytesize * 2)
+    assert_equal @test_data, decompressed
+  end
+
+  def test_constants
+    assert LZ4Native::LZ4::MAX_INPUT_SIZE.is_a?(Integer)
+    assert LZ4Native::LZ4::MAX_INPUT_SIZE > 0
+  end
+end