Added a method to check if the data is compressed or not

CachedQuickLz/CachedQlzCommon.cs

@@ -30,6 +30,23 @@ public static int SizeCompressed(byte[] source)
             return source[1];
         }
 
+        /// <summary>
+        /// Returns if the array is compressed or not
+        /// </summary>
+        /// <param name="source">Array with compressed bytes</param>
+        /// <param name="length">Length of the array</param>
+        /// <returns>If the array is compressed with QuickLz or not</returns>
+        public static bool IsCompressed(byte[] source, int length)
+        {
+            var trailEquals = true;
+            for (var i = length - 1; i > length - QlzConstants.QlzTrailLength; i--)
+            {
+                trailEquals &= source[i] == QlzConstants.QlzTrailingBytes[QlzConstants.QlzTrailLength - (length - i)];
+            }
+
+            return trailEquals;
+        }
+
         private static int HeaderLen(IList<byte> source)
         {
             return (source[0] & 2) == 2 ? 9 : 3;
@@ -50,5 +67,13 @@ private static void Fastwrite(IList<byte> a, int i, int value, int numbytes)
             for (var j = 0; j < numbytes; j++)
                 a[i + j] = (byte)(value >> (j * 8));
         }
+
+        private static void WriteTrailingBytes(IList<byte> dst, int length)
+        {
+            for (var i = 0; i < QlzConstants.QlzTrailLength; i++)
+            {
+                dst[length + i] = QlzConstants.QlzTrailingBytes[i];
+            }
+        }
     }
 }

CachedQuickLz/CachedQlzCompress.cs

@@ -23,7 +23,7 @@ public static void Compress(ref byte[] data, ref int length, int level = 3)
             var dst = QlzConstants.DefaultHeaderlen + QlzConstants.CwordLen;
             var cwordVal = 0x80000000;
             var cwordPtr = QlzConstants.DefaultHeaderlen;
-            var destination = ArrayPool<byte>.Spawn(length + 400);
+            var destination = ArrayPool<byte>.Spawn(length + 500);
             var cachetable = ArrayPool<int>.Spawn(QlzConstants.HashValues);
             var hashCounter = ArrayPool<byte>.Spawn(QlzConstants.HashValues);
             byte[] d2;
@@ -43,8 +43,8 @@ public static void Compress(ref byte[] data, ref int length, int level = 3)
                     if (src > length >> 1 && dst > src - (src >> 5))
                     {
                         var newLength = length + QlzConstants.DefaultHeaderlen;
-                        d2 = ArrayPool<byte>.Spawn(length + QlzConstants.DefaultHeaderlen);
-                        WriteHeader(d2, level, false, length, length + QlzConstants.DefaultHeaderlen);
+                        d2 = ArrayPool<byte>.Spawn(newLength + QlzConstants.QlzTrailLength);
+                        WriteHeader(d2, level, false, length, newLength);
                         Array.Copy(data, 0, d2, QlzConstants.DefaultHeaderlen, length);
 
                         ArrayPool<byte>.Recycle(destination);
@@ -53,8 +53,10 @@ public static void Compress(ref byte[] data, ref int length, int level = 3)
                         ArrayPool<byte>.Recycle(data);
                         HasthablePool.RecycleHashtable(hashtable);
 
+                        WriteTrailingBytes(d2, newLength);
+
                         data = d2;
-                        length = newLength;
+                        length = newLength + QlzConstants.QlzTrailLength;
                         return;
                     }
 
@@ -241,11 +243,12 @@ public static void Compress(ref byte[] data, ref int length, int level = 3)
             HasthablePool.RecycleHashtable(hashtable);
             ArrayPool<byte>.Recycle(data);
 
-            d2 = ArrayPool<byte>.Spawn(dst);
+            d2 = ArrayPool<byte>.Spawn(dst + QlzConstants.DefaultHeaderlen + QlzConstants.QlzTrailLength);
             Array.Copy(destination, d2, dst);
+            WriteTrailingBytes(d2, dst);
             ArrayPool<byte>.Recycle(destination);
 
-            length = dst;
+            length = dst + QlzConstants.QlzTrailLength;
             data = d2;
         }
     }

CachedQuickLz/QlzConstants.cs

@@ -2,6 +2,9 @@
 {
     public class QlzConstants
     {
+        public const int QlzTrailLength = 9;
+        public static readonly byte[] QlzTrailingBytes = { 12, 8, 87, 28, 10, 88, 28, 7, 17 };
+
         public const int QlzVersionMajor = 1;
         public const int QlzVersionMinor = 5;
         public const int QlzVersionRevision = 0;

CachedQuickLzTests/CachedQuickLzTests.csproj

@@ -47,6 +47,7 @@
     <Compile Include="DecompressionTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="TestCommon.cs" />
+    <Compile Include="CompressionCheckTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

CachedQuickLzTests/CompressionCheckTests.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Text;
+using CachedQuickLz;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CachedQuickLzTests
+{
+    [TestClass]
+    public class CompressionCheckTests
+    {
+        [TestMethod]
+        public void TestCheckArrayIsCompressed_ImpossibleToCompress()
+        {
+            var numBytes = 100;
+
+            var data = new byte[numBytes];
+            new Random().NextBytes(data);
+            CachedQlz.Compress(ref data, ref numBytes);
+
+            Assert.IsTrue(CachedQlz.IsCompressed(data, numBytes));
+        }
+
+        [TestMethod]
+        public void TestCheckArrayIsCompressed_NoIssues()
+        {
+            var numBytes = 5000;
+
+            var text = Encoding.ASCII.GetBytes(TestCommon.RandomString(numBytes));
+            CachedQlz.Compress(ref text, ref numBytes);
+
+            Assert.IsTrue(CachedQlz.IsCompressed(text, numBytes));
+        }
+
+        [TestMethod]
+        public void TestCheckArrayIsNotCompressed()
+        {
+            var data = new byte[100];
+            new Random().NextBytes(data);
+
+            Assert.IsFalse(CachedQlz.IsCompressed(data, 100));
+        }
+    }
+}

appveyor.yml

@@ -23,7 +23,7 @@ image: Visual Studio 2017
 #---------------------------------#
 
 environment:
-  smallversion: 1.1
+  smallversion: 1.2
   NugetKey:
     secure: tYPzvkyTyLs55bvneeVzag8tp+r3qjFlRbLcllo4g/g96oMBBxhd+p3wzxZHUvgk
 cache: