dependency update

build.gradle

@@ -0,0 +1,59 @@
+plugins {
+    id 'java-library'
+    id 'maven-publish'
+    alias(catalog.plugins.lombok) apply false
+    alias(catalog.plugins.multi.release.jar)
+}
+
+group = "net.woggioni"
+version = getProperty("jzstd.version")
+
+
+allprojects {
+    apply plugin: catalog.plugins.lombok.get().pluginId
+
+    repositories {
+        maven {
+            url = 'https://woggioni.net/mvn/'
+        }
+        mavenCentral()
+    }
+
+    lombok {
+        version = catalog.versions.lombok
+    }
+
+    dependencies {
+        testRuntimeOnly catalog.junit.jupiter.engine
+        testImplementation catalog.junit.jupiter.api
+        testImplementation catalog.junit.jupiter.params
+    }
+
+    tasks.withType(Test) {
+        useJUnitPlatform()
+    }
+}
+
+compileJava {
+    options.release = 8
+    options.compilerArgs << '-parameters'
+}
+
+dependencies {
+    implementation catalog.jna
+}
+
+publishing {
+    repositories {
+        maven {
+            url = 'https://mvn.woggioni.net/'
+        }
+    }
+    publications {
+        maven(MavenPublication) {
+            from(components["java"])
+        }
+    }
+}
+
+

build.gradle.kts

@@ -1,42 +0,0 @@
-plugins {
-    `java-library`
-}
-
-group = "net.woggioni"
-version = "0.1"
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-}
-
-allprojects {
-
-    repositories {
-        mavenLocal()
-        jcenter()
-        mavenCentral()
-    }
-}
-
-fun property(name : String) = project.property(name).toString()
-
-dependencies {
-    implementation("net.java.dev.jna", "jna", property("jna.version"))
-
-    // https://mvnrepository.com/artifact/org.projectlombok/lombok
-    compileOnly("org.projectlombok", "lombok", property("lombok.version"))
-    annotationProcessor("org.projectlombok", "lombok", property("lombok.version"))
-
-    testCompileOnly("org.projectlombok", "lombok", property("lombok.version"))
-    testAnnotationProcessor("org.projectlombok", "lombok", property("lombok.version"))
-    testRuntimeOnly("org.junit.jupiter", "junit-jupiter-engine", property("junit.version"))
-    testImplementation("org.junit.jupiter","junit-jupiter-api", property("junit.version"))
-    testImplementation("org.junit.jupiter","junit-jupiter-params", property("junit.version"))
-}
-
-
-tasks.withType<Test> {
-    useJUnitPlatform {
-    }
-}

cli/build.gradle

@@ -0,0 +1,33 @@
+plugins {
+    alias catalog.plugins.kotlin.jvm
+    alias catalog.plugins.envelope
+}
+
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import net.woggioni.gradle.envelope.EnvelopeJarTask
+
+dependencies {
+    implementation catalog.kotlin.stdlib.jdk8
+
+    implementation catalog.log4j.slf4j2.impl
+    implementation catalog.slf4j.api
+    implementation catalog.jcommander
+    implementation rootProject
+}
+
+Provider<EnvelopeJarTask> envelopeJarTaskProvider = tasks.named('envelopeJar', EnvelopeJarTask.class) {
+    mainClass = 'net.woggioni.jzstd.Cli'
+}
+
+tasks.named('envelopeRun', JavaExec) {
+    args = ['--help']
+}
+
+tasks.withType(KotlinCompile.class).configureEach {
+    kotlinOptions {
+        languageVersion = "1.9"
+        apiVersion = "1.9"
+        jvmTarget = "17"
+        javaParameters = true
+    }
+}

cli/build.gradle.kts

@@ -1,49 +0,0 @@
-plugins {
-    id("org.jetbrains.kotlin.jvm") version "1.3.70"
-    application
-}
-
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-
-group = "net.woggioni"
-version = "0.1"
-
-fun property(name : String) = project.property(name).toString()
-
-dependencies {
-    // Align versions of all Kotlin components
-    implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
-
-    // Use the Kotlin JDK 8 standard library.
-    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-
-    implementation("org.apache.logging.log4j", "log4j-slf4j-impl", property("log4j.version"))
-    implementation("org.slf4j", "slf4j-api", property("slf4j.version"))
-    implementation("com.beust", "jcommander", property("jcommander.version"))
-    implementation(project(":"))
-
-    testRuntimeOnly("org.junit.jupiter", "junit-jupiter-engine", property("junit.version"))
-    testImplementation("org.junit.jupiter","junit-jupiter-api", property("junit.version"))
-    testImplementation("org.junit.jupiter","junit-jupiter-params", property("junit.version"))
-}
-
-application {
-    mainClassName = "net.woggioni.jzstd.Cli"
-}
-
-
-tasks.withType<Test> {
-    useJUnitPlatform {
-    }
-}
-
-
-tasks.withType<KotlinCompile>().configureEach {
-    kotlinOptions {
-        languageVersion = "1.3"
-        apiVersion = "1.3"
-        jvmTarget = "1.8"
-        javaParameters = true   // Useful for reflection.
-    }
-}

cli/src/test/kotlin/InsaneTest.kt

@@ -1,22 +0,0 @@
-import net.woggioni.jzstd.ZstdOutputStream
-import org.junit.jupiter.api.Test
-import java.nio.file.Files
-import java.nio.file.Paths
-
-class InsaneTest {
-
-    @Test
-    fun test2() {
-        val inputFile = Paths.get("/tmp/Richard_Dawkins_The_Selfish_Gene.pdf")
-        Files.newInputStream(inputFile).use { `is` ->
-            ZstdOutputStream.from(Files.newOutputStream(Paths.get("/tmp/Richard_Dawkins_The_Selfish_Gene.pdf.zst"))).use { os ->
-                val buffer = ByteArray(0x10000)
-                while (true) {
-                    val read = `is`.read(buffer)
-                    if (read < 0) break
-                    os.write(buffer, 0, read)
-                }
-            }
-        }
-    }
-}

gradle.properties

@@ -1,7 +1,5 @@
-junit.version=5.6.2
+jzstd.version = 2023.07.15
-lombok.version=1.18.12
+
-jna.version=5.5.0
+jpms.module.name = net.woggioni.jzstd
-kotlin.version=1.3.70
+
-jcommander.version=1.78
+lys.version = 2023.07.09
-slf4j.version=1.7.30
-log4j.version=2.13.2

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,240 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# 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
+#
+#      https://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.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,91 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,36 @@
+pluginManagement {
+    repositories {
+        maven {
+            url = 'https://woggioni.net/mvn/'
+            content {
+                includeModule 'net.woggioni.gradle', 'envelope'
+                includeModule 'net.woggioni.gradle.envelope', 'net.woggioni.gradle.envelope.gradle.plugin'
+                includeModule 'net.woggioni.gradle', 'lombok'
+                includeModule 'net.woggioni.gradle.lombok', 'net.woggioni.gradle.lombok.gradle.plugin'
+                includeModule 'net.woggioni.gradle', 'multi-release-jar'
+                includeModule 'net.woggioni.gradle.multi-release-jar', 'net.woggioni.gradle.multi-release-jar.gradle.plugin'
+            }
+        }
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        maven {
+            url = 'https://woggioni.net/mvn/'
+            content {
+                includeGroup 'com.lys'
+            }
+        }
+    }
+    versionCatalogs {
+        catalog {
+            from group: 'com.lys', name: 'lys-catalog', version: getProperty('lys.version')
+        }
+    }
+}
+
+rootProject.name = "jzstd"
+
+include("cli")

settings.gradle.kts

@@ -1,3 +0,0 @@
-rootProject.name = "jzstd"
-
-include("cli")

src/main/java/net/woggioni/jzstd/ZstdInputStream.java

@@ -15,6 +15,7 @@ public class ZstdInputStream extends InputStream {
 
     private final ZSTD_inBuffer input;
     private final ZSTD_outBuffer output;
+    private final byte[] buffer;
 
     private enum State {
         AVAILABLE_INPUT, SOURCE_DEPLETED, CTX_FLUSHED
@@ -33,6 +34,7 @@ public class ZstdInputStream extends InputStream {
         this.ctx_owner = ctx_owner;
         this.input = new ZSTD_inBuffer(inputBufferSize);
         this.output = new ZSTD_outBuffer(outputBufferSize);
+        this.buffer = new byte[inputBufferSize];
     }
 
     public static ZstdInputStream from(InputStream source) {
@@ -52,23 +54,24 @@ public class ZstdInputStream extends InputStream {
             if (input.pos.intValue() == input.size.intValue()) {
                 if (state == State.SOURCE_DEPLETED) {
                     return;
-                } else if(input.src.position() == input.src.capacity()) {
+                } else if (input.src.position() == input.src.capacity()) {
                     input.src.position(0);
                 }
-                while (input.src.position() < input.src.capacity()) {
+
-                    int b = source.read();
+                int toRead = input.src.capacity() - input.src.position();
-                    if (b < 0) {
+                if (toRead > 0) {
+                    int read = source.read(buffer, 0, toRead);
+                    if (read < 0) {
                         state = State.SOURCE_DEPLETED;
                         break;
                     }
-                    input.src.put((byte) b);
+                    input.src.put(buffer, 0, toRead);
                 }
                 input.pos = zero;
                 input.size = new size_t(input.src.position());
-                output.pos = zero;
             }
             int rc = ZstdLibrary.decompressStream(ctx.ctx, output, input);
-            if(rc == 0) {
+            if (rc == 0) {
                 state = State.CTX_FLUSHED;
                 break;
             }
@@ -89,15 +92,14 @@ public class ZstdInputStream extends InputStream {
     public int read(byte[] arr, int off, int len) {
         int totalRead = 0;
         while (totalRead < len) {
-            if(output.pos.intValue() == output.dst.position()) {
+            if (output.pos.intValue() == output.dst.position()) {
-                if(state == State.CTX_FLUSHED) {
+                if (state == State.CTX_FLUSHED) {
-                    if(totalRead == 0) --totalRead;
+                    if (totalRead == 0) --totalRead;
                     break;
-                }
+                } else fill();
-                else fill();
             }
-            int toBeRead = Math.min(len, output.pos.intValue() - output.dst.position());
+            int toBeRead = Math.min(len - totalRead, output.pos.intValue() - output.dst.position());
-            output.dst.get(arr, off, toBeRead);
+            output.dst.get(arr, off + totalRead, toBeRead);
             totalRead += toBeRead;
         }
         return totalRead;

src/main/java/net/woggioni/jzstd/internal/ZSTD_inBuffer.java

@@ -12,7 +12,7 @@ public class ZSTD_inBuffer extends Structure {
     public size_t pos;
 
     public ZSTD_inBuffer(int size) {
-        this.src = ByteBuffer.allocateDirect(size);
+        this.src = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder());
         this.size = new size_t(this.src.capacity());
         this.pos = new size_t(this.src.capacity());
     }

src/main/java/net/woggioni/jzstd/internal/ZSTD_outBuffer.java

@@ -12,7 +12,7 @@ public class ZSTD_outBuffer extends Structure {
     public size_t pos;
 
     public ZSTD_outBuffer(int size) {
-        this.dst = ByteBuffer.allocateDirect(size);
+        this.dst = ByteBuffer.allocateDirect(size).order(ByteOrder.nativeOrder());
         this.size = new size_t(dst.capacity());
         this.pos = new size_t(0);
     }

src/main/java9/module-info.java

@@ -0,0 +1,3 @@
+module net.woggioni.jzstd {
+    exports net.woggioni.jzstd;
+}

src/test/java/net/woggioni/jzstd/BasicTest.java

@@ -2,7 +2,8 @@ package net.woggioni.jzstd;
 
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayNameGeneration;
+import org.junit.jupiter.api.DisplayNameGenerator;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -15,7 +16,10 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
+import java.util.Arrays;
 import java.util.Random;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 class SplitOutputStream extends OutputStream {
@@ -61,7 +65,7 @@ class HexSequenceGenerator extends InputStream {
     public int read() {
         int result;
         if (count < length) {
-            result = chars[(int)(count % chars.length)];
+            result = chars[(int) (count % chars.length)];
             ++count;
         } else result = -1;
         return result;
@@ -70,11 +74,11 @@ class HexSequenceGenerator extends InputStream {
     @Override
     @SneakyThrows
     public int read(byte[] arr, int off, int len) {
-        if(count == length) return -1;
+        if (count == length) return -1;
         else {
             int i;
             for (i = 0; i < len && count + i < length; i++) {
-                arr[i] = (byte) chars[(int)((count + i) % chars.length)];
+                arr[i] = (byte) chars[(int) ((count + i) % chars.length)];
             }
             count += i;
             return i;
@@ -106,7 +110,7 @@ class RandomBytesGenerator extends InputStream {
     @Override
     @SneakyThrows
     public int read(byte[] arr, int off, int len) {
-        if(count == length) return -1;
+        if (count == length) return -1;
         else {
             int i;
             for (i = 0; i < len && count + i < length; i++) {
@@ -124,7 +128,7 @@ public class BasicTest {
 
     public static String bytesToHex(byte[] bytes) {
         char[] hexChars = new char[bytes.length * 2];
-        for(int j = 0; j < bytes.length; j++) {
+        for (int j = 0; j < bytes.length; j++) {
             int v = bytes[j] & 0xFF;
             hexChars[j * 2] = hexArray[v >>> 4];
             hexChars[j * 2 + 1] = hexArray[v & 0x0F];
@@ -132,25 +136,36 @@ public class BasicTest {
         return new String(hexChars);
     }
 
-    private static class InputStreamProvider implements ArgumentsProvider {
+    private static class TestCaseProvider implements ArgumentsProvider {
 
         @Override
         @SneakyThrows
         public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
-            return Stream.of(
+            Supplier<InputStream>[] streams = new Supplier[]{
-                    Arguments.of(getClass().getResourceAsStream("/index.html")),
+                    () -> getClass().getResourceAsStream("/index.html"),
-                    Arguments.of(new RandomBytesGenerator(123456, 1000)),
+                    () -> new RandomBytesGenerator(123456, 1000),
-                    Arguments.of(new RandomBytesGenerator(654321, 65536)),
+                    () -> new RandomBytesGenerator(654321, 65536),
-                    Arguments.of(new RandomBytesGenerator(101325, 12345678)),
+                    () -> new RandomBytesGenerator(101325, 12345678),
-                    Arguments.of(new HexSequenceGenerator(12345678))
+                    () -> new HexSequenceGenerator(12345678)
-            );
+            };
+            int[] bufferSizes = new int[]{
+                    0x100,
+                    0x1000,
+                    0x10000,
+                    0x100000
+            };
+
+            return Arrays.stream(streams)
+                    .flatMap(s -> Arrays.stream(bufferSizes).mapToObj(bufferSize -> Arguments.of(s.get(), bufferSize)));
         }
     }
 
+    private static final Path temporaryDirectory = Paths.get(System.getProperty("java.io.tmpdir"));
+
     @SneakyThrows
     @ParameterizedTest
-    @ArgumentsSource(InputStreamProvider.class)
+    @ArgumentsSource(TestCaseProvider.class)
-    public void test(InputStream testStream) {
+    public void test(InputStream testStream, int bufferSize) {
         MessageDigest md5 = MessageDigest.getInstance("MD5");
         boolean debug = false;
 
@@ -160,17 +175,17 @@ public class BasicTest {
             OutputStream os;
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
             os = baos;
-            if(debug) {
+            if (debug) {
-                os = new SplitOutputStream(os, Files.newOutputStream(Paths.get("/tmp/out.bin.zst")));
+                os = new SplitOutputStream(os, Files.newOutputStream(temporaryDirectory.resolve("out.bin.zst")));
             }
             os = ZstdOutputStream.from(os);
             if (debug) {
-                new SplitOutputStream(
+                os = new SplitOutputStream(
                         os,
-                        Files.newOutputStream(Paths.get("/tmp/out.bin.original")));
+                        Files.newOutputStream(temporaryDirectory.resolve("/tmp/out.bin.original")));
             }
             try {
-                byte[] buffer = new byte[0x100000];
+                byte[] buffer = new byte[bufferSize];
                 while (true) {
                     int read = is.read(buffer);
                     if (read < 0) break;
@@ -188,10 +203,29 @@ public class BasicTest {
         md5.reset();
         try (InputStream is = new DigestInputStream(
                 ZstdInputStream.from(compressedStream), md5)) {
-            byte[] buffer = new byte[0x10000];
+            OutputStream os;
-            while (true) {
+            if(debug) {
-                int read = is.read(buffer);
+                os = Files.newOutputStream(temporaryDirectory.resolve("out.bin"));
-                if (read < 0) break;
+            } else {
+                os = new OutputStream() {
+                    @Override
+                    public void write(int i) {
+                    }
+
+                    @Override
+                    public void write(byte[] b, int off, int len) {
+                    }
+                };
+            }
+            try {
+                byte[] buffer = new byte[bufferSize];
+                while (true) {
+                    int read = is.read(buffer);
+                    if (read < 0) break;
+                    os.write(buffer, 0, read);
+                }
+            } finally {
+                os.close();
             }
         }
         byte[] roundTripDigest = md5.digest();