-

Author: vishalcoc44

src/test/java/org/xerial/snappy/fuzz/BitShuffleFuzzer.java

@@ -20,62 +20,43 @@
 import org.xerial.snappy.Snappy;
 import org.xerial.snappy.BitShuffle;
 import java.util.Arrays;
+import java.util.function.Function;
 
 public class BitShuffleFuzzer {
   private static final int SIZE = 4096;
 
   public static void fuzzerTestOneInput(FuzzedDataProvider data) {
-    fuzzBitshuffleInts(data.consumeInts(SIZE));
-    fuzzBitshuffleLongs(data.consumeLongs(SIZE));
-    fuzzBitshuffleShorts(data.consumeShorts(SIZE));
-  }
-
-  private static void runFuzz(RunnableWithException block) {
-    try {
-      block.run();
-    } catch (Exception e) {
-      throw new RuntimeException(e);
-    }
+    fuzzBitshuffle(data.consumeInts(SIZE), BitShuffle::shuffle, BitShuffle::unshuffleIntArray, "int[]");
+    fuzzBitshuffle(data.consumeLongs(SIZE), BitShuffle::shuffle, BitShuffle::unshuffleLongArray, "long[]");
+    fuzzBitshuffle(data.consumeShorts(SIZE), BitShuffle::shuffle, BitShuffle::unshuffleShortArray, "short[]");
   }
 
   @FunctionalInterface
-  private interface RunnableWithException {
+  private interface ExceptionRunnable {
     void run() throws Exception;
   }
 
-  private static void fuzzBitshuffleInts(int[] original) {
-    runFuzz(() -> {
-      byte[] shuffledByteArray = BitShuffle.shuffle(original);
-      byte[] compressed = Snappy.compress(shuffledByteArray);
-      byte[] uncompressed = Snappy.uncompress(compressed);
-      int[] result = BitShuffle.unshuffleIntArray(uncompressed);
-      if (!Arrays.equals(original, result)) {
-        throw new IllegalStateException("Original and uncompressed data are different");
-      }
-    });
+  @FunctionalInterface
+  private interface ShuffleFn<T> {
+    byte[] apply(T input) throws Exception;
   }
 
-  private static void fuzzBitshuffleLongs(long[] original) {
-    runFuzz(() -> {
-      byte[] shuffledByteArray = BitShuffle.shuffle(original);
-      byte[] compressed = Snappy.compress(shuffledByteArray);
-      byte[] uncompressed = Snappy.uncompress(compressed);
-      long[] result = BitShuffle.unshuffleLongArray(uncompressed);
-      if (!Arrays.equals(original, result)) {
-        throw new IllegalStateException("Original and uncompressed data are different");
-      }
-    });
+  @FunctionalInterface
+  private interface UnshuffleFn<T> {
+    T apply(byte[] input) throws Exception;
   }
 
-  private static void fuzzBitshuffleShorts(short[] original) {
-    runFuzz(() -> {
-      byte[] shuffledByteArray = BitShuffle.shuffle(original);
+  private static <T> void fuzzBitshuffle(T original, ShuffleFn<T> shuffle, UnshuffleFn<T> unshuffle, String typeName) {
+    try {
+      byte[] shuffledByteArray = shuffle.apply(original);
       byte[] compressed = Snappy.compress(shuffledByteArray);
       byte[] uncompressed = Snappy.uncompress(compressed);
-      short[] result = BitShuffle.unshuffleShortArray(uncompressed);
-      if (!Arrays.equals(original, result)) {
-        throw new IllegalStateException("Original and uncompressed data are different");
+      T result = unshuffle.apply(uncompressed);
+      if (!Arrays.equals((Object[]) original, (Object[]) result)) {
+        throw new IllegalStateException("Original and uncompressed " + typeName + " data are different");
       }
-    });
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
   }
 }

src/test/java/org/xerial/snappy/fuzz/FuzzBlock.java

@@ -0,0 +1,22 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package org.xerial.snappy.fuzz;
+
+@FunctionalInterface
+public interface FuzzBlock {
+    void run() throws Exception;
+}

src/test/java/org/xerial/snappy/fuzz/SnappyCombinedFuzzer.java

@@ -33,11 +33,6 @@
 
 public class SnappyCombinedFuzzer {
 
-    @FunctionalInterface
-    private interface FuzzBlock {
-        void run() throws Exception;
-    }
-    
     private static void runFuzz(FuzzBlock block) {
         try {
             block.run();
@@ -199,15 +194,14 @@ private static void testCrc32C(FuzzedDataProvider data) {
         }
 
         PureJavaCrc32C crcChunked = new PureJavaCrc32C();
-        for (int i = 0; i < Math.min(input.length, 1000); i++) {
+        for (int i = 0; i < input.length; i++) {
             crcChunked.update(input[i] & 0xFF);
         }
 
         PureJavaCrc32C crcWhole = new PureJavaCrc32C();
         crcWhole.update(input, 0, input.length);
-        long wholeValue = crcWhole.getValue();
 
-        if (input.length <= 1000 && crcChunked.getValue() != wholeValue) {
+        if (crcChunked.getValue() != crcWhole.getValue()) {
             throw new IllegalStateException("CRC32C chunked vs whole mismatch");
         }
     }

src/test/java/org/xerial/snappy/fuzz/SnappyStreamFuzzer.java

@@ -31,11 +31,6 @@
  */
 public class SnappyStreamFuzzer {
 
-    @FunctionalInterface
-    private interface FuzzBlock {
-        void run() throws Exception;
-    }
-    
     private static void runFuzz(FuzzBlock block) {
         try {
             block.run();