From d2d0aadfebde1f8ba28f0aa37aefd8190f83f1e9 Mon Sep 17 00:00:00 2001
From: "Taro L. Saito" <leo@xerial.org>
Date: Fri, 22 Dec 2017 13:35:44 -0800
Subject: [PATCH] Add simple test

---
 .../xerial/snappy/SnappyPerformanceTest.scala | 90 +++++++++++++++++--
 1 file changed, 85 insertions(+), 5 deletions(-)

diff --git a/src/test/scala/org/xerial/snappy/SnappyPerformanceTest.scala b/src/test/scala/org/xerial/snappy/SnappyPerformanceTest.scala
index 2a1c2a9b..d3ac7d5d 100644
--- a/src/test/scala/org/xerial/snappy/SnappyPerformanceTest.scala
+++ b/src/test/scala/org/xerial/snappy/SnappyPerformanceTest.scala
@@ -1,6 +1,7 @@
 package org.xerial.snappy
 
-import java.io.{ByteArrayOutputStream, ByteArrayInputStream}
+import java.io.{ByteArrayInputStream, ByteArrayOutputStream, DataOutputStream}
+import java.util.zip.GZIPOutputStream
 
 import scala.util.Random
 
@@ -11,7 +12,6 @@ class SnappyPerformanceTest extends SnappySpec {
 
   lazy val data = {
     val a = new Array[Byte](128 * 1024 * 1024)
-
     for (i <- (0 until a.length).par) {
       a(i) = Math.sin(i * 0.01).toByte
     }
@@ -21,9 +21,7 @@ class SnappyPerformanceTest extends SnappySpec {
   "SnappyOutputStream" should {
 
     "improve output performance" taggedAs ("out") in {
-
       val input = data
-
       time("compression", repeat = 100) {
         // 0.037 sec. => 0.026
         block("default") {
@@ -33,10 +31,92 @@ class SnappyPerformanceTest extends SnappySpec {
           sout.close()
           out.close()
         }
+      }
+      //info(f"compressed size: ${compressed.length}%,d, input: ${data.length}%,d")
+    }
 
+    "improve int compression ratio with bit-shuffle" taggedAs("int") in {
+      val N = 10000
+      val d = (0 until N).map(x => Random.nextInt(100)).toArray[Int]
+
+      time("int-compression", repeat = 1, blockRepeat = 1) {
+        block("bitshuffle") {
+          val shuffled = BitShuffle.shuffle(d)
+          val compressed = Snappy.compress(shuffled)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompressed = BitShuffle.unshuffleIntArray(Snappy.uncompress(compressed))
+        }
+        block("default") {
+          val compressed = Snappy.compress(d)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompress = Snappy.uncompress(compressed)
+
+        }
+        block("gzip") {
+          val out = new ByteArrayOutputStream()
+          val o = new DataOutputStream(new GZIPOutputStream(out))
+          d.foreach(x => o.writeInt(x))
+          o.close()
+          val compressed = out.toByteArray
+          logger.info(s"compressed size: ${compressed.length}")
+        }
       }
+    }
 
-      //info(f"compressed size: ${compressed.length}%,d, input: ${data.length}%,d")
+    "improve long compression ratio with bit-shuffle" taggedAs("long") in {
+      val N = 10000
+      val d = (0 until N).map(x => Random.nextInt(10000).toLong).toArray[Long]
+
+      time("long-compression", repeat = 1, blockRepeat = 1) {
+        block("bitshuffle") {
+          val shuffled = BitShuffle.shuffle(d)
+          val compressed = Snappy.compress(shuffled)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompressed = BitShuffle.unshuffleLongArray(Snappy.uncompress(compressed))
+        }
+        block("default") {
+          val compressed = Snappy.compress(d)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompress = Snappy.uncompress(compressed)
+        }
+        block("gzip") {
+          val out = new ByteArrayOutputStream()
+          val o = new DataOutputStream(new GZIPOutputStream(out))
+          d.foreach(x => o.writeLong(x))
+          o.close()
+          val compressed = out.toByteArray
+          logger.info(s"compressed size: ${compressed.length}")
+        }
+      }
+    }
+
+    "improve double compression ratio with bit-shuffle" taggedAs("double") in {
+      val N = 10000
+      val d = (0 until N).map(x => Random.nextInt(1000).toDouble).toArray[Double]
+
+      time("double-compression", repeat = 1, blockRepeat = 1) {
+        block("bitshuffle") {
+          val shuffled = BitShuffle.shuffle(d)
+          val compressed = Snappy.compress(shuffled)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompressed = BitShuffle.unshuffleDoubleArray(Snappy.uncompress(compressed))
+        }
+        block("default") {
+          val compressed = Snappy.compress(d)
+          logger.info(s"compressed size: ${compressed.length}")
+          val decompress = Snappy.uncompress(compressed)
+
+        }
+        block("gzip") {
+          val out = new ByteArrayOutputStream()
+          val o = new DataOutputStream(new GZIPOutputStream(out))
+          d.foreach(x => o.writeDouble(x))
+          o.close()
+          val compressed = out.toByteArray
+          logger.info(s"compressed size: ${compressed.length}")
+        }
+
+      }
     }
 
   }