[maven-release-plugin] prepare for next development iteration

[maven-release-plugin] prepare release twelvemonkeys-3.10.1
Set versions to 3.10.1-SNAPSHOT
2026-05-19 00:00:03 -04:00 · 2023-11-07 20:24:45 +01:00 · 2023-11-07 20:24:40 +01:00 · 2023-11-07 20:17:30 +01:00
346 changed files with 4345 additions and 7659 deletions
@@ -5,13 +5,9 @@ updates:
    directory: "/"
    schedule:
      interval: "daily"
-    cooldown:
-      default-days: 7
    open-pull-requests-limit: 10
  # GitHub actions updates
  - package-ecosystem: "github-actions"
    directory: "/.github/workflows"
    schedule:
      interval: "daily"
-    cooldown:
-      default-days: 7
@@ -17,16 +17,13 @@ jobs:
      fail-fast: false
      matrix:
        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        java: [ 8, 11, 17, 21, 25 ]
-        exclude:
-          - os: macos-latest
-            java: 8
+        java: [ 8, 11, 17, 21 ]
    runs-on: ${{ matrix.os }}
    permissions:
      checks: write
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/setup-java@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
        with:
          distribution: 'temurin'
          java-version: ${{ matrix.java }}
@@ -35,35 +32,13 @@ jobs:
      - name: Run Tests
        run: mvn --batch-mode --no-transfer-progress test
      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@74626db7353a25a20a72816467ebf035f674c5f8 # v5
+        uses: mikepenz/action-junit-report@0831a82caad2465c31c6dd929978f640cb42556c # v4.0.3
        if: ${{ !cancelled() }}
        with:
          report_paths: "**/target/surefire-reports/TEST*.xml"
          check_name: Unit Test Results for OpenJDK ${{ matrix.java }} on ${{ matrix.os }}

-  test-jdk8-macos:
-    name: Test OpenJDK 8 on macos-14
-    runs-on: macos-14
-    permissions:
-      checks: write
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
-        with:
-          distribution: 'zulu'
-          java-version: '8'
-          java-package: jdk
-          cache: 'maven'
-      - name: Run Tests
-        run: mvn --batch-mode --no-transfer-progress test
-      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@74626db7353a25a20a72816467ebf035f674c5f8 # v5
-        if: ${{ !cancelled() }}
-        with:
-          report_paths: "**/target/surefire-reports/TEST*.xml"
-          check_name: Unit Test Results for OpenJDK ${{ matrix.java }} on ${{ matrix.os }}
-
-  test-oracle:
+  test_oracle:
    name: Test Oracle JDK 8 with KCMS=${{ matrix.kcms }}
    runs-on: ubuntu-latest
    permissions:
@@ -72,11 +47,11 @@ jobs:
      matrix:
        kcms: [ true, false ]
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - run: |
          download_url="https://javadl.oracle.com/webapps/download/AutoDL?BundleId=245038_d3c52aa6bfa54d3ca74e617f18309292"
          wget -O $RUNNER_TEMP/java_package.tar.gz $download_url
-      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+      - uses: actions/setup-java@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
        with:
          distribution: 'jdkfile'
          jdkFile: ${{ runner.temp }}/java_package.tar.gz
@@ -91,53 +66,37 @@ jobs:
      - name: Run Tests
        run: mvn --batch-mode --no-transfer-progress test
      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@74626db7353a25a20a72816467ebf035f674c5f8 # v5
+        uses: mikepenz/action-junit-report@0831a82caad2465c31c6dd929978f640cb42556c # v4.0.3
        if: ${{ !cancelled() }}
        with:
          report_paths: "**/target/surefire-reports/TEST*.xml"
          check_name: Unit Test Results for Oracle JDK 8 with KCMS=${{ matrix.kcms }}

-  javadoc:
-    name: Build JavaDoc on OpenJDK ${{ matrix.java }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        java: [8, 11, 25 ] # We only need a few versions here
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
-        with:
-          distribution: 'temurin'
-          java-version: ${{ matrix.java }}
-          java-package: jdk
-          cache: 'maven'
-      - name: Create JavaDoc
-        run: mvn --batch-mode --no-transfer-progress -DskipTests package javadoc:javadoc
-
  release:
    name: Deploy
-    needs: [ test, test-jdk8-macos, test-oracle, javadoc ]
+    needs: [ test, test_oracle ]
    if: github.ref == 'refs/heads/master' # only perform on latest master
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: Set up Maven Central
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        uses: actions/setup-java@0ab4596768b603586c0de567f2430c30f5b0d2b0 # v3.13.0
        with: # running setup-java again overwrites the settings.xml
          distribution: 'temurin'
          java-version: '8'
          java-package: jdk
-          server-id: central # Value of the distributionManagement/repository/id field of the pom.xml
+          server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml
          server-username: MAVEN_CENTRAL_USERNAME # env variable for username in deploy (1)
          server-password: MAVEN_CENTRAL_PASSWORD # env variable for token in deploy (2)
+          gpg-private-key: ${{ secrets.GPG_KEY }} # Value of the GPG private key to import
+          gpg-passphrase: MAVEN_CENTRAL_GPG_PASSPHRASE # env variable for GPG private key passphrase (3)
      - name: Get Project Version
        run: |
          echo "PROJECT_VERSION=$(mvn --batch-mode help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
      - name: Publish to Maven Central
        if: ${{ endsWith(env.PROJECT_VERSION, '-SNAPSHOT') }}
-        run: mvn --batch-mode --no-transfer-progress deploy -P release -DskipTests -Dgpg.signer=bc
+        run: mvn --batch-mode --no-transfer-progress deploy -P release -DskipTests
        env:
-          MAVEN_CENTRAL_USERNAME: ${{ secrets.CENTRAL_USERNAME }} # must be the same env variable name as (1)
-          MAVEN_CENTRAL_PASSWORD: ${{ secrets.CENTRAL_PASSWORD }} # must be the same env variable name as (2)
-          MAVEN_GPG_KEY: ${{ secrets.GPG_KEY }}                    # Value of the GPG private key to import
-          MAVEN_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
+          MAVEN_CENTRAL_USERNAME: ${{ secrets.SONATYPE_USERNAME }} # must be the same env variable name as (1)
+          MAVEN_CENTRAL_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }} # must be the same env variable name as (2)
+          MAVEN_CENTRAL_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} # must be the same env variable name as (3)
@@ -33,11 +33,11 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
+      uses: github/codeql-action/init@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@@ -51,7 +51,7 @@ jobs:
    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
+      uses: github/codeql-action/autobuild@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -64,6 +64,6 @@ jobs:
    #     ./location_of_script_within_repo/buildscript.sh

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
+      uses: github/codeql-action/analyze@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
      with:
        category: "/language:${{matrix.language}}"
@@ -26,12 +26,12 @@ jobs:

    steps:
      - name: "Checkout code"
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
        with:
          persist-credentials: false

      - name: "Run analysis"
-        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
        with:
          results_file: results.sarif
          results_format: sarif
@@ -49,7 +49,7 @@ jobs:
      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
      # format to the repository Actions tab.
      - name: "Upload artifact"
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
        with:
          name: SARIF file
          path: results.sarif
@@ -57,6 +57,6 @@ jobs:

      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
+        uses: github/codeql-action/upload-sarif@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
        with:
          sarif_file: results.sarif
@@ -4,7 +4,7 @@
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7900/badge)](https://www.bestpractices.dev/projects/7900)

 [![Maven Central](https://img.shields.io/maven-central/v/com.twelvemonkeys.imageio/imageio?color=slateblue)](https://search.maven.org/search?q=g:com.twelvemonkeys.imageio)
-[![Maven Snapshot](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Fcentral.sonatype.com%2Frepository%2Fmaven-snapshots%2Fcom%2Ftwelvemonkeys%2Fimageio%2Fimageio%2Fmaven-metadata.xml&label=development&server=https%3A%2F%2Foss.sonatype.org&color=slateblue)](https://central.sonatype.com/repository/maven-snapshots/com/twelvemonkeys/imageio/imageio/maven-metadata.xml)
+[![Maven Snapshot](https://img.shields.io/nexus/s/com.twelvemonkeys.imageio/imageio?label=development&server=https%3A%2F%2Foss.sonatype.org&color=slateblue)](https://oss.sonatype.org/content/repositories/snapshots/com/twelvemonkeys/)
 [![StackOverflow](https://img.shields.io/badge/stack_overflow-twelvemonkeys-orange.svg)](https://stackoverflow.com/questions/tagged/twelvemonkeys)
 [![Donate](https://img.shields.io/badge/donate-PayPal-blue.svg)](https://paypal.me/haraldk76/100)

@@ -14,7 +14,7 @@

 TwelveMonkeys ImageIO provides extended image file format support for the Java platform, through plugins for the `javax.imageio.*` package.

-The main goal of this project is to provide support for file formats not covered by the JDK. 
+The main goal of this project is to provide support for formats not covered by the JRE itself. 
 Support for these formats is important, to be able to read data found
 "in the wild", as well as to maintain access to data in legacy formats.
 As there is lots of legacy data out there, we see the need for open implementations of readers for popular formats.
@@ -29,8 +29,7 @@ As there is lots of legacy data out there, we see the need for open implementati
 |        | WMF      | MS Windows Metafile                                     | ✔ |  -  | - | Requires [Batik](https://xmlgraphics.apache.org/batik/) |
 | [BMP](https://github.com/haraldk/TwelveMonkeys/wiki/BMP-Plugin)    | **BMP**  | MS Windows and IBM OS/2 Device Independent Bitmap       | ✔  |  ✔  | [Native](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/bmp_metadata.html), [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |
 |        | CUR      | MS Windows Cursor Format                                | ✔  |  -  | - |
-|        | ICO      | MS Windows Icon Format                                  | ✔  |  ✔  | - |
-| [DDS](https://github.com/haraldk/TwelveMonkeys/wiki/DDS-Plugin)   | DDS           | MS Direct Draw Surface Format                           | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) |
+|        | ICO      | MS Windows Icon Format                                  | ✔  |  ✔  | - | 
 | [HDR](https://github.com/haraldk/TwelveMonkeys/wiki/HDR-Plugin)    | HDR      | Radiance High Dynamic Range RGBE Format                 | ✔  |  -  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
 | [ICNS](https://github.com/haraldk/TwelveMonkeys/wiki/ICNS-Plugin)   | ICNS     | Apple Icon Image                                        | ✔  |  ✔  | -  | 
 | [IFF](https://github.com/haraldk/TwelveMonkeys/wiki/IFF-Plugin)    | IFF      | Commodore Amiga/Electronic Arts Interchange File Format | ✔  |  ✔  | [Standard](https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html) | 
@@ -223,43 +222,6 @@ BufferedImageOp ditherer = new DiffusionDither();
 BufferedImage output = ditherer.filter(input, null);
 ```

-#### Working with damaged images
-
-When using the normal patterns for loading images, trying to load a damaged image will result in an `IOException` being thrown.
-
-```java
-BufferedImage image = null;
-try {
-    image = ImageIO.read(file);
-} catch (IOException exception) {
-    // Handle, log a warning/error etc
-}
-```
-
-In this scenario, if the image is damaged, and `ImageIO.read` throws an exception, `image` is still `null` - it's not possible for a function to both return a value and throw an exception.
-
-However, in some cases it may be possible to get usable image data from a damaged image. The way to do this is use an `ImageReadParam` to set a `BufferedImage` as a destination.
-
-```java
-int width = reader.getWidth(0);
-int height = reader.getHeight(0);
-ImageTypeSpecifier imageType = reader.getRawImageType(0);
-BufferedImage image = imageType.createBufferedImage(width, height);
-
-ImageReadParam param = reader.getDefaultReadParam();
-param.setDestination(image);
-
-try {
-    reader.read(0, param);
-}
-catch (IOException e) {
-    // Handle, log a warning/error etc
-}
-```
-
-In theory this should work for all plugins, but the result is very much plugin/implementation specific. With some formats and some forms of damaged file, you may get an image that is mostly useful.
-However, you should be prepared for the possibility this just gives a blank or empty image.
-
 ## Building

 Download the project (using [Git](https://git-scm.com/downloads)):
@@ -316,12 +278,12 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-jpeg</artifactId>
-        <version>3.13.1</version>
+        <version>3.9.4</version>
    </dependency>
    <dependency>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio-tiff</artifactId>
-        <version>3.13.1</version>
+        <version>3.9.4</version>
    </dependency>

    <!--
@@ -331,7 +293,7 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.servlet</groupId>
        <artifactId>servlet</artifactId>
-        <version>3.13.1</version>
+        <version>3.9.4</version>
    </dependency>

    <!--
@@ -340,7 +302,7 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM
    <dependency>
        <groupId>com.twelvemonkeys.servlet</groupId>
        <artifactId>servlet</artifactId>
-        <version>3.13.1</version>
+        <version>3.9.4</version>
        <classifier>jakarta</classifier>
    </dependency>
 </dependencies>
@@ -350,18 +312,18 @@ To depend on the JPEG and TIFF plugin using Maven, add the following to your POM

 To depend on the JPEG and TIFF plugin in your IDE or program, add all of the following JARs to your class path:

-    twelvemonkeys-common-lang-3.13.1.jar
-    twelvemonkeys-common-io-3.13.1.jar
-    twelvemonkeys-common-image-3.13.1.jar
-    twelvemonkeys-imageio-core-3.13.1.jar
-    twelvemonkeys-imageio-metadata-3.13.1.jar
-    twelvemonkeys-imageio-jpeg-3.13.1.jar
-    twelvemonkeys-imageio-tiff-3.13.1.jar
+    twelvemonkeys-common-lang-3.9.4.jar
+    twelvemonkeys-common-io-3.9.4.jar
+    twelvemonkeys-common-image-3.9.4.jar
+    twelvemonkeys-imageio-core-3.9.4.jar
+    twelvemonkeys-imageio-metadata-3.9.4.jar
+    twelvemonkeys-imageio-jpeg-3.9.4.jar
+    twelvemonkeys-imageio-tiff-3.9.4.jar

 #### Deploying the plugins in a web app

-Because the `ImageIO` plugin registry (the `IIORegistry`) is "VM global", it does not work well with
-servlet contexts as-is. This is especially evident if you load plugins from the `WEB-INF/lib` or `classes` folder.
+Because the `ImageIO` plugin registry (the `IIORegistry`) is "VM global", it doesn't by default work well with
+servlet contexts. This is especially evident if you load plugins from the `WEB-INF/lib` or `classes` folder.
 Unless you add `ImageIO.scanForPlugins()` somewhere in your code, the plugins might never be available at all.

 In addition, servlet contexts dynamically loads and unloads classes (using a new class loader per context).
@@ -397,16 +359,6 @@ or other ImageIO plugins as well.

 Another safe option, is to place the JAR files in the application server's shared or common lib folder. 

-##### Jakarta Servlet Support
-
-For those transitioning from the old `javax.servlet` to the new `jakarta.servlet` package, there is a separate 
-dependency available. It contains exactly the same servlet classes as mentioned above, but built against the new Jakarta EE
-packages. The dependency has the same group name and identifier as before, but a `jakarta` *classifier* appended, to 
-distinguish it from the non-Jakarta package.
-
-See the [Maven dependency example](#maven-dependency-example) for how to enable it with Maven. 
-Gradle or other build tools will have similar options.
-
 #### Including the plugins in a "fat" JAR

 The recommended way to use the plugins, is just to include the JARs as-is in your project, through a Maven dependency or similar. 
@@ -432,46 +384,44 @@ Other "fat" JAR bundlers will probably have similar mechanisms to merge entries

 ### Links to prebuilt binaries

-##### Latest version (3.13.1)
+##### Latest version (3.9.4)

 The latest version that will run on Java 7 is 3.9.4. Later versions will require Java 8 or later.
 
 Common dependencies
-* [common-lang-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.13.1/common-lang-3.13.1.jar)
-* [common-io-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.13.1/common-io-3.13.1.jar)
-* [common-image-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.13.1/common-image-3.13.1.jar)
+* [common-lang-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-lang/3.9.4/common-lang-3.9.4.jar)
+* [common-io-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-io/3.9.4/common-io-3.9.4.jar)
+* [common-image-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/common/common-image/3.9.4/common-image-3.9.4.jar)

 ImageIO dependencies
-* [imageio-core-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.13.1/imageio-core-3.13.1.jar)
-* [imageio-metadata-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.13.1/imageio-metadata-3.13.1.jar)
+* [imageio-core-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-core/3.9.4/imageio-core-3.9.4.jar)
+* [imageio-metadata-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-metadata/3.9.4/imageio-metadata-3.9.4.jar)

 ImageIO plugins
-* [imageio-bmp-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.13.1/imageio-bmp-3.13.1.jar)
-* [imageio-dds-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-dds/3.13.1/imageio-dds-3.13.1.jar)
-* [imageio-hdr-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.13.1/imageio-hdr-3.13.1.jar)
-* [imageio-icns-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.13.1/imageio-icns-3.13.1.jar)
-* [imageio-iff-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.13.1/imageio-iff-3.13.1.jar)
-* [imageio-jpeg-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.13.1/imageio-jpeg-3.13.1.jar)
-* [imageio-pcx-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.13.1/imageio-pcx-3.13.1.jar)
-* [imageio-pict-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.13.1/imageio-pict-3.13.1.jar)
-* [imageio-pnm-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.13.1/imageio-pnm-3.13.1.jar)
-* [imageio-psd-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.13.1/imageio-psd-3.13.1.jar)
-* [imageio-sgi-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.13.1/imageio-sgi-3.13.1.jar)
-* [imageio-tga-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.13.1/imageio-tga-3.13.1.jar)
-* [imageio-thumbsdb-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.13.1/imageio-thumbsdb-3.13.1.jar)
-* [imageio-tiff-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.13.1/imageio-tiff-3.13.1.jar)
-* [imageio-webp-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-webp/3.13.1/imageio-webp-3.13.1.jar)
-* [imageio-xwd-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-xwd/3.13.1/imageio-xwd-3.13.1.jar)
+* [imageio-bmp-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-bmp/3.9.4/imageio-bmp-3.9.4.jar)
+* [imageio-hdr-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-hdr/3.9.4/imageio-hdr-3.9.4.jar)
+* [imageio-icns-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-icns/3.9.4/imageio-icns-3.9.4.jar)
+* [imageio-iff-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-iff/3.9.4/imageio-iff-3.9.4.jar)
+* [imageio-jpeg-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-jpeg/3.9.4/imageio-jpeg-3.9.4.jar)
+* [imageio-pcx-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pcx/3.9.4/imageio-pcx-3.9.4.jar)
+* [imageio-pict-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pict/3.9.4/imageio-pict-3.9.4.jar)
+* [imageio-pnm-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-pnm/3.9.4/imageio-pnm-3.9.4.jar)
+* [imageio-psd-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-psd/3.9.4/imageio-psd-3.9.4.jar)
+* [imageio-sgi-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-sgi/3.9.4/imageio-sgi-3.9.4.jar)
+* [imageio-tga-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tga/3.9.4/imageio-tga-3.9.4.jar)
+* [imageio-thumbsdb-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-thumbsdb/3.9.4/imageio-thumbsdb-3.9.4.jar)
+* [imageio-tiff-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-tiff/3.9.4/imageio-tiff-3.9.4.jar)
+* [imageio-webp-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-webp/3.9.4/imageio-webp-3.9.4.jar)
+* [imageio-xwd-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-xwd/3.9.4/imageio-xwd-3.9.4.jar)

 ImageIO plugins requiring 3rd party libs
-* [imageio-batik-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.13.1/imageio-batik-3.13.1.jar)
+* [imageio-batik-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-batik/3.9.4/imageio-batik-3.9.4.jar)

 Photoshop Path support for ImageIO
-* [imageio-clippath-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.13.1/imageio-clippath-3.13.1.jar)
+* [imageio-clippath-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/imageio/imageio-clippath/3.9.4/imageio-clippath-3.9.4.jar)

 Servlet support
-* [servlet-3.13.1.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.13.1/servlet-3.13.1.jar) for legacy Java EE (javax.servlet)
-* [servlet-3.13.1-jakarta.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.13.1/servlet-3.13.1-jakrta.jar) for Jakarta EE (jakarta.servlet)
+* [servlet-3.9.4.jar](https://search.maven.org/remotecontent?filepath=com/twelvemonkeys/servlet/servlet/3.9.4/servlet-3.9.4.jar)

 ## License

@@ -5,7 +5,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>

    <groupId>com.twelvemonkeys.bom</groupId>
@@ -63,11 +63,6 @@
                <artifactId>imageio-hdr</artifactId>
                <version>${project.version}</version>
            </dependency>
-            <dependency>
-                <groupId>com.twelvemonkeys.imageio</groupId>
-                <artifactId>imageio-dds</artifactId>
-                <version>${project.version}</version>
-            </dependency>
            <dependency>
                <groupId>com.twelvemonkeys.imageio</groupId>
                <artifactId>imageio-icns</artifactId>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>common-image</artifactId>
    <packaging>jar</packaging>
@@ -28,6 +28,13 @@
            <artifactId>common-io</artifactId>
        </dependency>

+        <dependency>
+            <groupId>jmagick</groupId>
+            <artifactId>jmagick</artifactId>
+            <version>6.6.9</version>
+            <optional>true</optional>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>

    <build>
@@ -47,10 +47,10 @@ import java.util.Random;
 *  |3|5|1|
 *   - - -->
 * </p>
- * <table border="1">
+ * <table border="1" cellpadding="4" cellspacing="0">
 *     <caption>Floyd-Steinberg error-diffusion weights</caption>
- *     <tr><td style="background:#000000">&nbsp;</td><td class="TableHeadingColor"
- *          style="text-align:center">x</td><td>7/16</td></tr>
+ *     <tr><td bgcolor="#000000">&nbsp;</td><td class="TableHeadingColor"
+ *          align="center">x</td><td>7/16</td></tr>
 *     <tr><td>3/16</td><td>5/16</td><td>1/16</td></tr>
 * </table>
 * <p>
@@ -162,7 +162,7 @@ public final class ImageUtil {

    /**
     * The sharpen kernel. Uses the following 3 by 3 matrix:
-     * <table border="1">
+     * <table border="1" cellspacing="0">
     *     <caption>Sharpen Kernel Matrix</caption>
     *     <tr><td>0.0</td><td>-0.3</td><td>0.0</td></tr>
     *     <tr><td>-0.3</td><td>2.2</td><td>-0.3</td></tr>
@@ -1078,7 +1078,7 @@ public final class ImageUtil {
    /**
     * Sharpens an image using a convolution matrix.
     * The sharpen kernel used, is defined by the following 3 by 3 matrix:
-     * <table border="1">
+     * <table border="1" cellspacing="0">
     *     <caption>Sharpen Kernel Matrix</caption>
     *     <tr><td>0.0</td><td>-0.3</td><td>0.0</td></tr>
     *     <tr><td>-0.3</td><td>2.2</td><td>-0.3</td></tr>
@@ -1100,7 +1100,7 @@ public final class ImageUtil {
    /**
     * Sharpens an image using a convolution matrix.
     * The sharpen kernel used, is defined by the following 3 by 3 matrix:
-     * <table border="1">
+     * <table border="1" cellspacing="0">
     *     <caption>Sharpen Kernel Matrix</caption>
     *     <tr><td>0.0</td><td>-{@code pAmount}</td><td>0.0</td></tr>
     *     <tr><td>-{@code pAmount}</td>
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, Harald Kuhr
+ * Copyright (c) 2008, Harald Kuhr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -28,22 +28,28 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-package com.twelvemonkeys.imageio.plugins.dds;

-import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfo;
-import com.twelvemonkeys.imageio.spi.ReaderWriterProviderInfoTest;
+package com.twelvemonkeys.image;

 /**
- * DDSProviderInfoTest.
+ * Magick
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
- * @author last modified by $Author: harald.kuhr$
- * @version $Id: DDSProviderInfoTest.java,v 1.0 02/06/16 harald.kuhr Exp$
+ * @author last modified by $Author: haku $
+ * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/image/Magick.java#1 $
 */
-public class DDSProviderInfoTest extends ReaderWriterProviderInfoTest {
+final class Magick {
+    static final boolean DEBUG = useDebug();

-    @Override
-    protected ReaderWriterProviderInfo createProviderInfo() {
-        return new DDSProviderInfo();
+    private static boolean useDebug() {
+        try {
+            return "TRUE".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.image.magick.debug"));
+        }
+        catch (Throwable t) {
+            // Most probably in case of a SecurityManager
+            return false;
+        }
    }
-}
+
+    private Magick() {}
+}
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2008, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+package com.twelvemonkeys.image;
+
+import com.twelvemonkeys.lang.SystemUtil;
+import magick.MagickImage;
+
+import java.awt.image.BufferedImage;
+import java.awt.image.BufferedImageOp;
+
+/**
+ * This class accelerates certain graphics operations, using
+ * JMagick and ImageMagick, if available.
+ * If those libraries are not installed, this class silently does nothing.
+ * <p>
+ * Set the system property {@code "com.twelvemonkeys.image.accel"} to
+ * {@code false}, to disable, even if JMagick is installed.
+ * Set the system property {@code "com.twelvemonkeys.image.magick.debug"} to
+ * </p>
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/image/MagickAccelerator.java#3 $
+ */
+final class MagickAccelerator {
+
+    private static final boolean DEBUG = Magick.DEBUG;
+    private static final boolean USE_MAGICK = useMagick();
+
+    private static final int RESAMPLE_OP = 0;
+
+    private static Class[] nativeOp = new Class[1];
+
+    static {
+        try {
+            nativeOp[RESAMPLE_OP] = Class.forName("com.twelvemonkeys.image.ResampleOp");
+        }
+        catch (ClassNotFoundException e) {
+            System.err.println("Could not find class: " + e);
+        }
+    }
+
+    private static boolean useMagick() {
+        try {
+            boolean available = SystemUtil.isClassAvailable("magick.MagickImage");
+
+            if (DEBUG && !available) {
+                System.err.print("ImageMagick bindings not available.");
+            }
+
+            boolean useMagick =
+                    available && !"FALSE".equalsIgnoreCase(System.getProperty("com.twelvemonkeys.image.accel"));
+
+            if (DEBUG) {
+                System.err.println(
+                        useMagick
+                                ? "Will use ImageMagick bindings to accelerate image resampling operations."
+                                : "Will not use ImageMagick to accelerate image resampling operations."
+                );
+            }
+
+            return useMagick;
+        }
+        catch (Throwable t) {
+            // Most probably in case of a SecurityManager
+            System.err.println("Could not enable ImageMagick bindings: " + t);
+            return false;
+        }
+    }
+
+    private static int getNativeOpIndex(Class pOpClass) {
+        for (int i = 0; i < nativeOp.length; i++) {
+            if (pOpClass == nativeOp[i]) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public static BufferedImage filter(BufferedImageOp pOperation, BufferedImage pInput, BufferedImage pOutput) {
+        if (!USE_MAGICK) {
+            return null;
+        }
+
+        BufferedImage result = null;
+        switch (getNativeOpIndex(pOperation.getClass())) {
+            case RESAMPLE_OP:
+                ResampleOp resample = (ResampleOp) pOperation;
+                result = resampleMagick(pInput, resample.width, resample.height, resample.filterType);
+
+                // NOTE: If output parameter is non-null, we have to return that
+                // image, instead of result
+                if (pOutput != null) {
+                    //pOutput.setData(result.getRaster()); // Fast, but less compatible
+                    // NOTE: For some reason, this is sometimes super-slow...?
+                    ImageUtil.drawOnto(pOutput, result);
+                    result = pOutput;
+                }
+
+                break;
+
+            default:
+                // Simply fall through, allowing acceleration to be added later
+                break;
+
+        }
+        
+        return result;
+    }
+
+    private static BufferedImage resampleMagick(BufferedImage pSrc, int pWidth, int pHeight, int pFilterType) {
+        // Convert to Magick, scale and convert back
+        MagickImage image = null;
+        MagickImage scaled = null;
+        try {
+            image = MagickUtil.toMagick(pSrc);
+
+            long start = 0;
+            if (DEBUG) {
+                start = System.currentTimeMillis();
+            }
+
+            // NOTE: setFilter affects zoomImage, NOT scaleImage
+            image.setFilter(pFilterType);
+            scaled = image.zoomImage(pWidth, pHeight);
+            //scaled = image.scaleImage(pWidth, pHeight); // AREA_AVERAGING
+
+            if (DEBUG) {
+                long time = System.currentTimeMillis() - start;
+                System.out.println("Filtered: " + time + " ms");
+            }
+
+            return MagickUtil.toBuffered(scaled);
+        }
+        //catch (MagickException e) {
+        catch (Exception e) {
+            // NOTE: Stupid workaround: If MagickException is caught, a
+            // NoClassDefFoundError is thrown, when MagickException class is
+            // unavailable...
+            if (e instanceof RuntimeException) {
+                throw (RuntimeException) e;
+            }
+
+            throw new ImageConversionException(e.getMessage(), e);
+        }
+        finally {
+            // NOTE: ImageMagick might be unstable after a while, if image data
+            // is not deallocated. The GC/finalize method handles this, but in
+            // special circumstances, it's not triggered often enough.
+            if (image != null) {
+                image.destroyImages();
+            }
+            if (scaled != null) {
+                scaled.destroyImages();
+            }
+        }
+    }
+}
@@ -0,0 +1,621 @@
+/*
+ * Copyright (c) 2008, Harald Kuhr
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.twelvemonkeys.image;
+
+import magick.ImageType;
+import magick.MagickException;
+import magick.MagickImage;
+import magick.PixelPacket;
+
+import java.awt.*;
+import java.awt.color.ColorSpace;
+import java.awt.color.ICC_ColorSpace;
+import java.awt.color.ICC_Profile;
+import java.awt.image.*;
+
+/**
+ * Utility for converting JMagick {@code MagickImage}s to standard Java
+ * {@code BufferedImage}s and back.
+ * <p>
+ * <em>NOTE: This class is considered an implementation detail and not part of
+ * the public API. This class is subject to change without further notice. 
+ * You have been warned. :-)</em>
+ * </p>
+ *
+ * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
+ * @version $Id: //depot/branches/personal/haraldk/twelvemonkeys/release-2/twelvemonkeys-core/src/main/java/com/twelvemonkeys/image/MagickUtil.java#4 $
+ */
+public final class MagickUtil {
+    // IMPORTANT NOTE: Disaster happens if any of these constants are used outside this class
+    // because you then have a dependency on MagickException (this is due to Java class loading
+    // and initialization magic).
+    // Do not use outside this class. If the constants need to be shared, move to Magick or ImageUtil.
+
+    /** Color Model usesd for bilevel (B/W) */
+    private static final IndexColorModel CM_MONOCHROME = MonochromeColorModel.getInstance();
+
+    /** Color Model usesd for raw ABGR */
+    private static final ColorModel CM_COLOR_ALPHA =
+            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[] {8, 8, 8, 8},
+                            true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+
+    /** Color Model usesd for raw BGR */
+    private static final ColorModel CM_COLOR_OPAQUE =
+            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB), new int[] {8, 8, 8},
+                            false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+
+    /** Color Model usesd for raw RGB */
+    //private static final ColorModel CM_COLOR_RGB = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
+
+    /** Color Model usesd for raw GRAY + ALPHA */
+    private static final ColorModel CM_GRAY_ALPHA =
+            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY),
+                            true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE);
+
+    /** Color Model usesd for raw GRAY */
+    private static final ColorModel CM_GRAY_OPAQUE =
+            new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY),
+                            false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+
+    /** Band offsets for raw ABGR */
+    private static final int[] BAND_OFF_TRANS = new int[] {3, 2, 1, 0};
+
+    /** Band offsets for raw BGR */
+    private static final int[] BAND_OFF_OPAQUE = new int[] {2, 1, 0};
+
+    /** The point at {@code 0, 0} */
+    private static final Point LOCATION_UPPER_LEFT = new Point(0, 0);
+
+    private static final boolean DEBUG = Magick.DEBUG;
+
+    // Only static members and methods
+    private MagickUtil() {}
+
+    /**
+     * Converts a {@code MagickImage} to a {@code BufferedImage}.
+     * <p>
+     * The conversion depends on {@code pImage}'s {@code ImageType}:
+     * </p>
+     * <dl>
+     * <dt>{@code ImageType.BilevelType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_BYTE_BINARY}</dd>
+     *
+     * <dt>{@code ImageType.GrayscaleType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_BYTE_GRAY}</dd>
+     * <dt>{@code ImageType.GrayscaleMatteType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_USHORT_GRAY}</dd>
+     *
+     * <dt>{@code ImageType.PaletteType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_BYTE_BINARY} (for images
+     * with a palette of &lt;= 16 colors) or {@code TYPE_BYTE_INDEXED}</dd>
+     * <dt>{@code ImageType.PaletteMatteType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_BYTE_BINARY} (for images
+     * with a palette of &lt;= 16 colors) or {@code TYPE_BYTE_INDEXED}</dd>
+     *
+     * <dt>{@code ImageType.TrueColorType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_3BYTE_BGR}</dd>
+     * <dt>{@code ImageType.TrueColorPaletteType}</dt>
+     * <dd>{@code BufferedImage} of type {@code TYPE_4BYTE_ABGR}</dd>
+     * </dl>
+     *
+     * @param pImage the original {@code MagickImage}
+     * @return a new {@code BufferedImage}
+     *
+     * @throws IllegalArgumentException if {@code pImage} is {@code null}
+     * or if the {@code ImageType} is not one mentioned above.
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    public static BufferedImage toBuffered(MagickImage pImage) throws MagickException {
+        if (pImage == null) {
+            throw new IllegalArgumentException("image == null");
+        }
+
+        long start = 0L;
+        if (DEBUG) {
+            start = System.currentTimeMillis();
+        }
+
+        BufferedImage image = null;
+        try {
+            switch (pImage.getImageType()) {
+                case ImageType.BilevelType:
+                    image = bilevelToBuffered(pImage);
+                    break;
+                case ImageType.GrayscaleType:
+                    image = grayToBuffered(pImage, false);
+                    break;
+                case ImageType.GrayscaleMatteType:
+                    image = grayToBuffered(pImage, true);
+                    break;
+                case ImageType.PaletteType:
+                    image = paletteToBuffered(pImage, false);
+                    break;
+                case ImageType.PaletteMatteType:
+                    image = paletteToBuffered(pImage, true);
+                    break;
+                case ImageType.TrueColorType:
+                    image = rgbToBuffered(pImage, false);
+                    break;
+                case ImageType.TrueColorMatteType:
+                    image = rgbToBuffered(pImage, true);
+                    break;
+                case ImageType.ColorSeparationType:
+                    image = cmykToBuffered(pImage, false);
+                    break;
+                case ImageType.ColorSeparationMatteType:
+                    image = cmykToBuffered(pImage, true);
+                    break;
+                case ImageType.OptimizeType:
+                default:
+                    throw new IllegalArgumentException("Unknown JMagick image type: " + pImage.getImageType());
+            }
+
+        }
+        finally {
+            if (DEBUG) {
+                long time = System.currentTimeMillis() - start;
+                System.out.println("Converted JMagick image type: " + pImage.getImageType() + " to BufferedImage: " + image);
+                System.out.println("Conversion to BufferedImage: " + time + " ms");
+            }
+        }
+
+        return image;
+    }
+
+    /**
+     * Converts a {@code BufferedImage} to a {@code MagickImage}.
+     * <p>
+     * The conversion depends on {@code pImage}'s {@code ColorModel}:
+     * </p>
+     * <dl>
+     * <dt>{@code IndexColorModel} with 1 bit b/w</dt>
+     * <dd>{@code MagickImage} of type {@code ImageType.BilevelType}</dd>
+     * <dt>{@code IndexColorModel} &gt; 1 bit,</dt>
+     * <dd>{@code MagickImage} of type {@code ImageType.PaletteType}
+     * or {@code MagickImage} of type {@code ImageType.PaletteMatteType}
+     * depending on <tt>ColorModel.getAlpha()</tt></dd>
+     *
+     * <dt>{@code ColorModel.getColorSpace().getType() == ColorSpace.TYPE_GRAY}</dt>
+     * <dd>{@code MagickImage} of type {@code ImageType.GrayscaleType}
+     * or {@code MagickImage} of type {@code ImageType.GrayscaleMatteType}
+     * depending on <tt>ColorModel.getAlpha()</tt></dd>
+     *
+     * <dt>{@code ColorModel.getColorSpace().getType() == ColorSpace.TYPE_RGB}</dt>
+     * <dd>{@code MagickImage} of type {@code ImageType.TrueColorType}
+     * or {@code MagickImage} of type {@code ImageType.TrueColorPaletteType}</dd>
+     * </dl>
+     *
+     * @param pImage the original {@code BufferedImage}
+     * @return a new {@code MagickImage}
+     *
+     * @throws IllegalArgumentException if {@code pImage} is {@code null}
+     * or if the {@code ColorModel} is not one mentioned above.
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    public static MagickImage toMagick(BufferedImage pImage) throws MagickException {
+        if (pImage == null) {
+            throw new IllegalArgumentException("image == null");
+        }
+
+        long start = 0L;
+        if (DEBUG) {
+            start = System.currentTimeMillis();
+        }
+
+        try {
+            ColorModel cm = pImage.getColorModel();
+            if (cm instanceof IndexColorModel) {
+                // Handles both BilevelType, PaletteType and PaletteMatteType
+                return indexedToMagick(pImage, (IndexColorModel) cm, cm.hasAlpha());
+            }
+
+            switch (cm.getColorSpace().getType()) {
+                case ColorSpace.TYPE_GRAY:
+                    // Handles GrayType and GrayMatteType
+                    return grayToMagick(pImage, cm.hasAlpha());
+                case ColorSpace.TYPE_RGB:
+                    // Handles TrueColorType and TrueColorMatteType
+                    return rgbToMagic(pImage, cm.hasAlpha());
+                case ColorSpace.TYPE_CMY:
+                case ColorSpace.TYPE_CMYK:
+                case ColorSpace.TYPE_HLS:
+                case ColorSpace.TYPE_HSV:
+                    // Other types not supported yet
+                default:
+                    throw new IllegalArgumentException("Unknown buffered image type: " + pImage);
+            }
+        }
+        finally {
+            if (DEBUG) {
+                long time = System.currentTimeMillis() - start;
+                System.out.println("Conversion to MagickImage: " + time + " ms");
+            }
+        }
+    }
+
+    private static MagickImage rgbToMagic(BufferedImage pImage, boolean pAlpha) throws MagickException {
+        MagickImage image = new MagickImage();
+
+        BufferedImage buffered = ImageUtil.toBuffered(pImage, pAlpha ? BufferedImage.TYPE_4BYTE_ABGR : BufferedImage.TYPE_3BYTE_BGR);
+
+        // Need to get data of sub raster, not the full data array, this is
+        // just a convenient way
+        Raster raster;
+        if (buffered.getRaster().getParent() != null) {
+            raster = buffered.getData(new Rectangle(buffered.getWidth(), buffered.getHeight()));
+        }
+        else {
+            raster = buffered.getRaster();
+        }
+
+        image.constituteImage(buffered.getWidth(), buffered.getHeight(), pAlpha ? "ABGR" : "BGR",
+                              ((DataBufferByte) raster.getDataBuffer()).getData());
+
+        return image;
+    }
+
+    private static MagickImage grayToMagick(BufferedImage pImage, boolean pAlpha) throws MagickException {
+        MagickImage image = new MagickImage();
+
+        // TODO: Make a fix for TYPE_USHORT_GRAY
+        // The code below does not seem to work (JMagick issues?)...
+        /*
+        if (pImage.getType() == BufferedImage.TYPE_USHORT_GRAY) {
+            short[] data = ((DataBufferUShort) pImage.getRaster().getDataBuffer()).getData();
+            int[] intData = new int[data.length];
+            for (int i = 0; i < data.length; i++) {
+                intData[i] = (data[i] & 0xffff) * 0xffff;
+            }
+            image.constituteImage(pImage.getWidth(), pImage.getHeight(), "I", intData);
+
+            System.out.println("storageClass: " + image.getStorageClass());
+            System.out.println("depth: " + image.getDepth());
+            System.out.println("imageType: " + image.getImageType());
+        }
+        else {
+        */
+        BufferedImage buffered = ImageUtil.toBuffered(pImage, pAlpha ? BufferedImage.TYPE_4BYTE_ABGR : BufferedImage.TYPE_BYTE_GRAY);
+
+        // Need to get data of sub raster, not the full data array, this is
+        // just a convenient way
+        Raster raster;
+        if (buffered.getRaster().getParent() != null) {
+            raster = buffered.getData(new Rectangle(buffered.getWidth(), buffered.getHeight()));
+        }
+        else {
+            raster = buffered.getRaster();
+        }
+
+        image.constituteImage(buffered.getWidth(), buffered.getHeight(), pAlpha ? "ABGR" : "I", ((DataBufferByte) raster.getDataBuffer()).getData());
+        //}
+
+        return image;
+    }
+
+    private static MagickImage indexedToMagick(BufferedImage pImage, IndexColorModel pColorModel, boolean pAlpha) throws MagickException {
+        MagickImage image = rgbToMagic(pImage, pAlpha);
+
+        int mapSize = pColorModel.getMapSize();
+        image.setNumberColors(mapSize);
+
+        return image;
+    }
+
+    /*
+    public static MagickImage toMagick(BufferedImage pImage) throws MagickException {
+        if (pImage == null) {
+            throw new IllegalArgumentException("image == null");
+        }
+        
+        final int width = pImage.getWidth();
+        final int height = pImage.getHeight();
+
+        // int ARGB -> byte RGBA conversion
+        // NOTE: This is ImageMagick Q16 compatible raw RGBA format with 16 bits/sample...
+        //       For a Q8 build, we could probably go with half the space...
+        // NOTE: This is close to insanity, as it wastes extreme ammounts of memory
+        final int[] argb = new int[width];
+        final byte[] raw16 = new byte[width * height * 8];
+        for (int y = 0; y < height; y++) {
+            // Fetch one line of ARGB data
+            pImage.getRGB(0, y, width, 1, argb, 0, width);
+
+            for (int x = 0; x < width; x++) {
+                int pixel = (x + (y * width)) * 8;
+                raw16[pixel    ] = (byte) ((argb[x] >> 16) & 0xff); // R
+                raw16[pixel + 2] = (byte) ((argb[x] >>  8) & 0xff); // G
+                raw16[pixel + 4] = (byte) ((argb[x]      ) & 0xff); // B
+                raw16[pixel + 6] = (byte) ((argb[x] >> 24) & 0xff); // A
+            }
+        }
+
+        // Create magick image
+        ImageInfo info = new ImageInfo();
+        info.setMagick("RGBA"); // Raw RGBA samples
+        info.setSize(width + "x" + height); // String?!?
+
+        MagickImage image = new MagickImage(info);
+        image.setImageAttribute("depth", "8");
+
+        // Set pixel data in 16 bit raw RGBA format
+        image.blobToImage(info, raw16);
+
+        return image;
+    }
+    */
+
+    /**
+     * Converts a bi-level {@code MagickImage} to a {@code BufferedImage}, of
+     * type {@code TYPE_BYTE_BINARY}.
+     *
+     * @param pImage the original {@code MagickImage}
+     * @return a new {@code BufferedImage}
+     *
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    private static BufferedImage bilevelToBuffered(MagickImage pImage) throws MagickException {
+        // As there is no way to get the binary representation of the image,
+        // convert to gray, and the create a binary image from it
+        BufferedImage temp = grayToBuffered(pImage, false);
+
+        BufferedImage image = new BufferedImage(temp.getWidth(), temp.getHeight(), BufferedImage.TYPE_BYTE_BINARY, CM_MONOCHROME);
+
+        ImageUtil.drawOnto(image, temp);
+
+        return image;
+    }
+
+    /**
+     * Converts a gray {@code MagickImage} to a {@code BufferedImage}, of
+     * type {@code TYPE_USHORT_GRAY} or {@code TYPE_BYTE_GRAY}.
+     *
+     * @param pImage the original {@code MagickImage}
+     * @param pAlpha keep alpha channel
+     * @return a new {@code BufferedImage}
+     *
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    private static BufferedImage grayToBuffered(MagickImage pImage, boolean pAlpha) throws MagickException {
+        Dimension size = pImage.getDimension();
+        int length = size.width * size.height;
+        int bands = pAlpha ? 2 : 1;
+        byte[] pixels = new byte[length * bands];
+
+        // TODO: Make a fix for 16 bit TYPE_USHORT_GRAY?!
+        // Note: The ordering AI or I corresponds to BufferedImage
+        // TYPE_CUSTOM and TYPE_BYTE_GRAY respectively
+        pImage.dispatchImage(0, 0, size.width, size.height, pAlpha ? "AI" : "I", pixels);
+
+        // Init databuffer with array, to avoid allocation of empty array
+        DataBuffer buffer = new DataBufferByte(pixels, pixels.length);
+
+        int[] bandOffsets = pAlpha ? new int[] {1, 0} : new int[] {0};
+
+        WritableRaster raster =
+                Raster.createInterleavedRaster(buffer, size.width, size.height,
+                        size.width * bands, bands, bandOffsets, LOCATION_UPPER_LEFT);
+
+        return new BufferedImage(pAlpha ? CM_GRAY_ALPHA : CM_GRAY_OPAQUE, raster, pAlpha, null);
+    }
+
+    /**
+     * Converts a palette-based {@code MagickImage} to a
+     * {@code BufferedImage}, of type {@code TYPE_BYTE_BINARY} (for images
+     * with a palette of &lt;= 16 colors) or {@code TYPE_BYTE_INDEXED}.
+     *
+     * @param pImage the original {@code MagickImage}
+     * @param pAlpha keep alpha channel
+     * @return a new {@code BufferedImage}
+     *
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    private static BufferedImage paletteToBuffered(MagickImage pImage, boolean pAlpha) throws MagickException {
+        // Create indexcolormodel for the image
+        IndexColorModel cm;
+
+        try {
+            cm = createIndexColorModel(pImage.getColormap(), pAlpha);
+        }
+        catch (MagickException e) {
+            // NOTE: Some MagickImages incorrecly (?) reports to be paletteType,
+            //       but does not have a colormap, this is a workaround.
+            return rgbToBuffered(pImage, pAlpha);
+        }
+
+        // As there is no way to get the indexes of an indexed image, convert to
+        // RGB, and the create an indexed image from it
+        BufferedImage temp = rgbToBuffered(pImage, pAlpha);
+
+        BufferedImage image;
+        if (cm.getMapSize() <= 16) {
+            image = new BufferedImage(temp.getWidth(), temp.getHeight(), BufferedImage.TYPE_BYTE_BINARY, cm);
+        }
+        else {
+            image = new BufferedImage(temp.getWidth(), temp.getHeight(), BufferedImage.TYPE_BYTE_INDEXED, cm);
+        }
+
+        // Create transparent background for images containing alpha
+        if (pAlpha) {
+            Graphics2D g = image.createGraphics();
+            try {
+                g.setComposite(AlphaComposite.Clear);
+                g.fillRect(0, 0, temp.getWidth(), temp.getHeight());
+            }
+            finally {
+                g.dispose();
+            }
+        }
+
+        // NOTE: This is (surprisingly) much faster than using g2d.drawImage()..
+        // (Tests shows 20-30ms, vs. 600-700ms on the same image)
+        BufferedImageOp op = new CopyDither(cm);
+        op.filter(temp, image);
+
+        return image;
+    }
+
+    /**
+     * Creates an {@code IndexColorModel} from an array of
+     * {@code PixelPacket}s.
+     *
+     * @param pColormap the original colormap as a {@code PixelPacket} array
+     * @param pAlpha keep alpha channel
+     *
+     * @return a new {@code IndexColorModel}
+     */
+    public static IndexColorModel createIndexColorModel(PixelPacket[] pColormap, boolean pAlpha) {
+        int[] colors = new int[pColormap.length];
+
+        // TODO: Verify if this is correct for alpha...?
+        int trans = pAlpha ? colors.length - 1 : -1;
+
+        //for (int i = 0; i < pColormap.length; i++) {
+        for (int i = pColormap.length - 1; i != 0; i--) {
+            PixelPacket color = pColormap[i];
+            if (pAlpha) {
+                colors[i] = (0xff - (color.getOpacity() & 0xff)) << 24 |
+                            (color.getRed()     & 0xff) << 16 |
+                            (color.getGreen()   & 0xff) <<  8 |
+                            (color.getBlue()    & 0xff);
+            }
+            else {
+                colors[i] = (color.getRed()     & 0xff) << 16 |
+                            (color.getGreen()   & 0xff) <<  8 |
+                            (color.getBlue()    & 0xff);
+            }
+        }
+
+        return new InverseColorMapIndexColorModel(8, colors.length, colors, 0, pAlpha, trans, DataBuffer.TYPE_BYTE);
+    }
+
+    /**
+     * Converts an (A)RGB {@code MagickImage} to a {@code BufferedImage}, of
+     * type {@code TYPE_4BYTE_ABGR} or {@code TYPE_3BYTE_BGR}.
+     *
+     * @param pImage the original {@code MagickImage}
+     * @param pAlpha keep alpha channel
+     * @return a new {@code BufferedImage}
+     *
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    private static BufferedImage rgbToBuffered(MagickImage pImage, boolean pAlpha) throws MagickException {
+        Dimension size = pImage.getDimension();
+        int length = size.width * size.height;
+        int bands = pAlpha ? 4 : 3;
+        byte[] pixels = new byte[length * bands];
+
+        // TODO: If we do multiple dispatches (one per line, typically), we could provide listener
+        //       feedback. But it's currently a lot slower than fetching all the pixels in one go.
+
+        // Note: The ordering ABGR or BGR corresponds to BufferedImage
+        // TYPE_4BYTE_ABGR and TYPE_3BYTE_BGR respectively
+        pImage.dispatchImage(0, 0, size.width, size.height, pAlpha ? "ABGR" : "BGR", pixels);
+
+        // Init databuffer with array, to avoid allocation of empty array
+        DataBuffer buffer = new DataBufferByte(pixels, pixels.length);
+
+        int[] bandOffsets = pAlpha ? BAND_OFF_TRANS : BAND_OFF_OPAQUE;
+
+        WritableRaster raster =
+                Raster.createInterleavedRaster(buffer, size.width, size.height,
+                        size.width * bands, bands, bandOffsets, LOCATION_UPPER_LEFT);
+
+        return new BufferedImage(pAlpha ? CM_COLOR_ALPHA : CM_COLOR_OPAQUE, raster, pAlpha, null);
+    }
+	
+	
+	
+
+    /**
+     * Converts an {@code MagickImage} to a {@code BufferedImage} which holds an CMYK ICC profile
+     *
+     * @param pImage the original {@code MagickImage}
+     * @param pAlpha keep alpha channel
+     * @return a new {@code BufferedImage}
+     *
+     * @throws MagickException if an exception occurs during conversion
+     *
+     * @see BufferedImage
+     */
+    private static BufferedImage cmykToBuffered(MagickImage pImage, boolean pAlpha) throws MagickException {
+		Dimension size = pImage.getDimension();
+		int length = size.width * size.height;
+		
+		// Retreive the ICC profile
+		ICC_Profile profile = ICC_Profile.getInstance(pImage.getColorProfile().getInfo());
+		ColorSpace cs = new ICC_ColorSpace(profile);
+		
+		int bands = cs.getNumComponents() + (pAlpha ? 1 : 0);
+		
+		int[] bits = new int[bands];
+		for (int i = 0; i < bands; i++) {
+			bits[i] = 8;
+		}
+
+        ColorModel cm = pAlpha ?
+                new ComponentColorModel(cs, bits, true, true, Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE) :
+                new ComponentColorModel(cs, bits, false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
+
+        byte[] pixels = new byte[length * bands];
+
+		// TODO: If we do multiple dispatches (one per line, typically), we could provide listener
+		//       feedback. But it's currently a lot slower than fetching all the pixels in one go.
+		// TODO: handle more generic cases if profile is not CMYK
+		// TODO: Test "ACMYK"
+		pImage.dispatchImage(0, 0, size.width, size.height, pAlpha ? "ACMYK" : "CMYK", pixels);
+
+        // Init databuffer with array, to avoid allocation of empty array
+        DataBuffer buffer = new DataBufferByte(pixels, pixels.length);
+
+		// TODO: build array from bands variable, here it just works for CMYK
+		// The values has not been tested with an alpha picture actually...
+        int[] bandOffsets = pAlpha ? new int[] {0, 1, 2, 3, 4} : new int[] {0, 1, 2, 3};
+
+        WritableRaster raster =
+                Raster.createInterleavedRaster(buffer, size.width, size.height,
+                        size.width * bands, bands, bandOffsets, LOCATION_UPPER_LEFT);
+		
+        return new BufferedImage(cm, raster, pAlpha, null);
+		
+    }
+}
@@ -55,7 +55,9 @@
 package com.twelvemonkeys.image;

 import java.awt.*;
-import java.awt.geom.*;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
 import java.awt.image.*;

 /**
@@ -101,6 +103,15 @@ import java.awt.image.*;
 * BufferedImage scaled = new ResampleOp(w, h).filter(temp, null);
 * </pre></blockquote>
 * <p>
+ * For maximum performance, this class will use native code, through
+ * <a href="http://www.yeo.id.au/jmagick/">JMagick</a>, when available.
+ * Otherwise, the class will silently fall back to pure Java mode.
+ * Native code may be disabled globally, by setting the system property
+ * {@code com.twelvemonkeys.image.accel} to {@code false}.
+ * To allow debug of the native code, set the system property
+ * {@code com.twelvemonkeys.image.magick.debug} to {@code true}.
+ * </p>
+ * <p>
 * This {@code BufferedImageOp} is based on C example code found in
 * <a href="http://www.acm.org/tog/GraphicsGems/">Graphics Gems III</a>,
 * Filtered Image Rescaling, by Dale Schumacher (with additional improvments by
@@ -128,6 +139,9 @@ import java.awt.image.*;
 // TODO: Consider using AffineTransformOp for more operations!?
 public class ResampleOp implements BufferedImageOp/* TODO: RasterOp */ {

+    // NOTE: These MUST correspond to ImageMagick filter types, for the
+    // MagickAccelerator to work consistently (see magick.FilterType).
+
    /**
     * Undefined interpolation, filter method will use default filter.
     */
@@ -281,10 +295,11 @@ public class ResampleOp implements BufferedImageOp/* TODO: RasterOp */ {
            new Value(KEY_RESAMPLE_INTERPOLATION, "Blackman-Sinc", FILTER_BLACKMAN_SINC);

    // Member variables
-    private final int width;
-    private final int height;
+    // Package access, to allow access from MagickAccelerator
+    int width;
+    int height;

-    private final int filterType;
+    int filterType;

    /**
     * RendereingHints.Key implementation, works only with Value values.
@@ -532,6 +547,16 @@ public class ResampleOp implements BufferedImageOp/* TODO: RasterOp */ {
                // Fall through
        }

+        // Try to use native ImageMagick code
+        BufferedImage result = MagickAccelerator.filter(this, input, output);
+        if (result != null) {
+            return result;
+        }
+
+        // Otherwise, continue in pure Java mode
+
+        // TODO: What if output != null and wrong size? Create new? Render on only a part? Document?
+
        // If filter type != POINT or BOX and input has IndexColorModel, convert
        // to true color, with alpha reflecting that of the original color model.
        BufferedImage temp;
@@ -546,7 +571,7 @@ public class ResampleOp implements BufferedImageOp/* TODO: RasterOp */ {

        // Create or convert output to a suitable image
        // TODO: OPTIMIZE: Don't really need to convert all types to same as input
-        BufferedImage result = output != null && temp.getType() != BufferedImage.TYPE_CUSTOM ? /*output*/ ImageUtil.toBuffered(output, temp.getType()) : createCompatibleDestImage(temp, null);
+        result = output != null && temp.getType() != BufferedImage.TYPE_CUSTOM ? /*output*/ ImageUtil.toBuffered(output, temp.getType()) : createCompatibleDestImage(temp, null);

        resample(temp, result, filter);

@@ -1255,12 +1280,12 @@ public class ResampleOp implements BufferedImageOp/* TODO: RasterOp */ {
    /*
    *	image rescaling routine
    */
-    static class Contributor {
+    class Contributor {
        int pixel;
        double weight;
    }

-    static class ContributorList {
+    class ContributorList {
        int n;/* number of contributors (may be < p.length) */
        Contributor[] p;/* pointer to list of contributions */
    }
@@ -31,7 +31,9 @@
 package com.twelvemonkeys.image;

 import static java.lang.Math.min;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;

 import java.awt.color.ColorSpace;
 import java.awt.geom.AffineTransform;
@@ -47,7 +49,7 @@ import java.util.List;

 import javax.imageio.ImageTypeSpecifier;

-import org.junit.jupiter.api.Test;
+import org.junit.Test;

 /**
 * AffineTransformOpTest.
@@ -144,12 +146,12 @@ public class AffineTransformOpTest {
            BufferedImage jreResult = jreOp.filter(image, null);
            BufferedImage tmResult = tmOp.filter(image, null);

-            assertNotNull(tmResult, "No result!");
-            assertEquals(jreResult.getType(), tmResult.getType(), "Bad type");
-            assertEquals(jreResult.getColorModel(), tmResult.getColorModel(), "Incorrect color model");
+            assertNotNull("No result!", tmResult);
+            assertEquals("Bad type", jreResult.getType(), tmResult.getType());
+            assertEquals("Incorrect color model", jreResult.getColorModel(), tmResult.getColorModel());

-            assertEquals(jreResult.getWidth(), tmResult.getWidth(), "Incorrect width");
-            assertEquals(jreResult.getHeight(), tmResult.getHeight(), "Incorrect height");
+            assertEquals("Incorrect width", jreResult.getWidth(), tmResult.getWidth());
+            assertEquals("Incorrect height", jreResult.getHeight(), tmResult.getHeight());
        }
    }

@@ -162,7 +164,7 @@ public class AffineTransformOpTest {
            BufferedImage image = spec.createBufferedImage(width, height);

            BufferedImage tmResult = tmOp.filter(image, null);
-            assertNotNull(tmResult, "No result!");
+            assertNotNull("No result!", tmResult);

            BufferedImage jreResult = null;

@@ -174,18 +176,18 @@ public class AffineTransformOpTest {
            }

            if (jreResult != null) {
-                assertEquals(jreResult.getType(), tmResult.getType(), "Bad type");
-                assertEquals(jreResult.getColorModel(), tmResult.getColorModel(), "Incorrect color model");
+                assertEquals("Bad type", jreResult.getType(), tmResult.getType());
+                assertEquals("Incorrect color model", jreResult.getColorModel(), tmResult.getColorModel());

-                assertEquals(jreResult.getWidth(), tmResult.getWidth(), "Incorrect width");
-                assertEquals(jreResult.getHeight(), tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", jreResult.getWidth(), tmResult.getWidth());
+                assertEquals("Incorrect height", jreResult.getHeight(), tmResult.getHeight());
            }
            else {
-                assertEquals(spec.getBufferedImageType(), tmResult.getType(), "Bad type");
-                assertEquals(spec.getColorModel(), tmResult.getColorModel(), "Incorrect color model");
+                assertEquals("Bad type", spec.getBufferedImageType(), tmResult.getType());
+                assertEquals("Incorrect color model", spec.getColorModel(), tmResult.getColorModel());

-                assertEquals(height, tmResult.getWidth(), "Incorrect width");
-                assertEquals(width, tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", height, tmResult.getWidth());
+                assertEquals("Incorrect height", width, tmResult.getHeight());
            }
        }
    }
@@ -234,12 +236,12 @@ public class AffineTransformOpTest {
            }

            if (jreResult != null) {
-                assertEquals(jreResult.getWidth(), tmResult.getWidth(), "Incorrect width");
-                assertEquals(jreResult.getHeight(), tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", jreResult.getWidth(), tmResult.getWidth());
+                assertEquals("Incorrect height", jreResult.getHeight(), tmResult.getHeight());
            }
            else {
-                assertEquals(height, tmResult.getWidth(), "Incorrect width");
-                assertEquals(width, tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", height, tmResult.getWidth());
+                assertEquals("Incorrect height", width, tmResult.getHeight());
            }
        }
    }
@@ -275,12 +277,12 @@ public class AffineTransformOpTest {
            }

            if (jreResult != null) {
-                assertEquals(jreResult.getWidth(), tmResult.getWidth(), "Incorrect width");
-                assertEquals(jreResult.getHeight(), tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", jreResult.getWidth(), tmResult.getWidth());
+                assertEquals("Incorrect height", jreResult.getHeight(), tmResult.getHeight());
            }
            else {
-                assertEquals(height, tmResult.getWidth(), "Incorrect width");
-                assertEquals(width, tmResult.getHeight(), "Incorrect height");
+                assertEquals("Incorrect width", height, tmResult.getWidth());
+                assertEquals("Incorrect height", width, tmResult.getHeight());
            }
        }
    }
@@ -30,16 +30,17 @@

 package com.twelvemonkeys.image;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
+import org.junit.Ignore;
+import org.junit.Test;

 import java.awt.*;
 import java.awt.color.*;
 import java.awt.image.*;
 import java.net.URL;
-import java.time.Duration;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;

 /**
 * BufferedImageFactoryTestCase
@@ -49,58 +50,50 @@ import static org.junit.jupiter.api.Assertions.*;
 * @version $Id: BufferedImageFactoryTestCase.java,v 1.0 May 7, 2010 12:40:08 PM haraldk Exp$
 */
 public class BufferedImageFactoryTest {
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNullImage() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new BufferedImageFactory((Image) null);
-        });
+        new BufferedImageFactory((Image) null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNullProducer() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new BufferedImageFactory((ImageProducer) null);
-        });
+        new BufferedImageFactory((ImageProducer) null);
    }

    // NPE in Toolkit, ok
-    @Test
+    @Test(expected = RuntimeException.class)
    public void testGetBufferedImageErrorSourceByteArray() {
-        assertThrows(RuntimeException.class, () -> {
-            Image source = Toolkit.getDefaultToolkit().createImage((byte[]) null);
-            new BufferedImageFactory(source);
-        });
+        Image source = Toolkit.getDefaultToolkit().createImage((byte[]) null);
+
+        new BufferedImageFactory(source);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetBufferedImageErrorSourceImageProducer() {
        Image source = Toolkit.getDefaultToolkit().createImage((ImageProducer) null);
-        assertThrows(IllegalArgumentException.class, () -> {
-            new BufferedImageFactory(source);
-        });
+
+        new BufferedImageFactory(source);
    }

    // TODO: This is a quite serious bug, however, the bug is in the Toolkit, allowing such images in the first place...
    // In any case, there's not much we can do, except until someone is bored and kills the app/thread... :-P
-    @Disabled("Bug in Toolkit")
-    @Test
+    @Ignore("Bug in Toolkit")
+    @Test(timeout = 1000, expected = ImageConversionException.class)
    public void testGetBufferedImageErrorSourceString() {
-        assertTimeoutPreemptively(Duration.ofMillis(1000), () -> {
-            Image source = Toolkit.getDefaultToolkit().createImage((String) null);
-            BufferedImageFactory factory = new BufferedImageFactory(source);
-            assertThrows(ImageConversionException.class, factory::getBufferedImage);
-        });
+        Image source = Toolkit.getDefaultToolkit().createImage((String) null);
+
+        BufferedImageFactory factory = new BufferedImageFactory(source);
+        factory.getBufferedImage();
    }

    // This is a little random, and it would be nicer if we could throw an IllegalArgumentException on create.
    // Unfortunately, the API doesn't allow this...
-    @Test
+    @Test(timeout = 1000, expected = ImageConversionException.class)
    public void testGetBufferedImageErrorSourceURL() {
-        assertTimeoutPreemptively(Duration.ofMillis(1000), () -> {
-            Image source = Toolkit.getDefaultToolkit().createImage((String) null);
-            BufferedImageFactory factory = new BufferedImageFactory(source);
-            assertThrows(ImageConversionException.class, factory::getBufferedImage);
-        });
+        Image source = Toolkit.getDefaultToolkit().createImage(getClass().getResource("/META-INF/MANIFEST.MF"));
+
+        BufferedImageFactory factory = new BufferedImageFactory(source);
+        factory.getBufferedImage();
    }

    @Test
@@ -172,7 +165,7 @@ public class BufferedImageFactoryTest {

        assertEquals(3, colorModel.getNumColorComponents());
        assertEquals(ColorSpace.getInstance(ColorSpace.CS_sRGB), colorModel.getColorSpace());
-        assertInstanceOf(IndexColorModel.class, colorModel);
+        assertTrue(colorModel instanceof IndexColorModel);

        assertTrue(colorModel.hasAlpha());
        assertEquals(4, colorModel.getNumComponents());
@@ -203,7 +196,7 @@ public class BufferedImageFactoryTest {

        for (int y = 0; y < image.getHeight(); y++) {
            for (int x = 0; x < image.getWidth(); x++) {
-                assertEquals(original.getRGB(x * 2, y * 2), image.getRGB(x, y), "RGB[" + x + ", " + y + "]");
+                assertEquals("RGB[" + x + ", " + y + "]", original.getRGB(x * 2, y * 2), image.getRGB(x, y));
            }
        }
    }
@@ -226,7 +219,7 @@ public class BufferedImageFactoryTest {

        for (int y = 0; y < image.getHeight(); y++) {
            for (int x = 0; x < image.getWidth(); x++) {
-                assertEquals(original.getRGB(40 + x, 40 + y), image.getRGB(x, y), "RGB[" + x + ", " + y + "]");
+                assertEquals("RGB[" + x + ", " + y + "]", original.getRGB(40 + x, 40 + y), image.getRGB(x, y));
            }
        }
    }
@@ -250,7 +243,7 @@ public class BufferedImageFactoryTest {

        for (int y = 0; y < image.getHeight(); y++) {
            for (int x = 0; x < image.getWidth(); x++) {
-                assertEquals(original.getRGB(40 + x * 2, 40 + y * 2), image.getRGB(x, y), "RGB[" + x + ", " + y + "]");
+                assertEquals("RGB[" + x + ", " + y + "]", original.getRGB(40 + x * 2, 40 + y * 2), image.getRGB(x, y));
            }
        }
    }
@@ -30,7 +30,7 @@

 package com.twelvemonkeys.image;

-import org.junit.jupiter.api.Test;
+import org.junit.Test;

 import javax.imageio.ImageIO;
 import java.awt.*;
@@ -39,7 +39,7 @@ import java.awt.image.IndexColorModel;
 import java.awt.image.RenderedImage;
 import java.io.InputStream;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 public class ImageUtilTest {

@@ -116,8 +116,8 @@ public class ImageUtilTest {
    public void testImageIsNotBufferedImage() {
        // Should not be a buffered image
        assertFalse(
-                scaled instanceof BufferedImage,
-                "FOR SOME IMPLEMENTATIONS THIS MIGHT FAIL!\nIn that case, testToBufferedImage() will fail too."
+                "FOR SOME IMPLEMENTATIONS THIS MIGHT FAIL!\nIn that case, testToBufferedImage() will fail too.",
+                scaled instanceof BufferedImage
        );
    }

@@ -247,7 +247,7 @@ public class ImageUtilTest {
        if (original != notContrasted) { // Don't care to test if images are same
            for (int y = 0; y < original.getHeight(); y++) {
                for (int x = 0; x < original.getWidth(); x++) {
-                    assertEquals(original.getRGB(x, y), notContrasted.getRGB(x, y), "0 constrast should not change image");
+                    assertEquals("0 constrast should not change image", original.getRGB(x, y), notContrasted.getRGB(x, y));
                }
            }
        }
@@ -275,24 +275,24 @@ public class ImageUtilTest {

                // RED
                if (oR < 127) {
-                    assertTrue(oR >= cR && cR >= dR, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oR >= cR && cR >= dR);
                }
                else {
-                    assertTrue(oR <= cR && cR <= dR, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oR <= cR && cR <= dR);
                }
                // GREEN
                if (oG < 127) {
-                    assertTrue(oG >= cG && cG >= dG, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oG >= cG && cG >= dG);
                }
                else {
-                    assertTrue(oG <= cG && cG <= dG, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oG <= cG && cG <= dG);
                }
                // BLUE
                if (oB < 127) {
-                    assertTrue(oB >= cB && cB >= dB, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oB >= cB && cB >= dB);
                }
                else {
-                    assertTrue(oB <= cB && cB <= dB, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oB <= cB && cB <= dB);
                }
            }
        }
@@ -304,9 +304,9 @@ public class ImageUtilTest {
                int r = rgb >> 16 & 0xFF;
                int g = rgb >> 8 & 0xFF;
                int b = rgb & 0xFF;
-                assertTrue(r == 0 || r == 255, "Max contrast should only produce primary colors");
-                assertTrue(g == 0 || g == 255, "Max contrast should only produce primary colors");
-                assertTrue(b == 0 || b == 255, "Max contrast should only produce primary colors");
+                assertTrue("Max contrast should only produce primary colors", r == 0 || r == 255);
+                assertTrue("Max contrast should only produce primary colors", g == 0 || g == 255);
+                assertTrue("Max contrast should only produce primary colors", b == 0 || b == 255);
            }
        }

@@ -327,24 +327,24 @@ public class ImageUtilTest {

                // RED
                if (oR >= 127) {
-                    assertTrue(oR >= cR, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oR >= cR);
                }
                else {
-                    assertTrue(oR <= cR, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oR <= cR);
                }
                // GREEN
                if (oG >= 127) {
-                    assertTrue(oG >= cG, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oG >= cG);
                }
                else {
-                    assertTrue(oG <= cG, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oG <= cG);
                }
                // BLUE
                if (oB >= 127) {
-                    assertTrue(oB >= cB, "Contrast should be decreased or same");
+                    assertTrue("Contrast should be decreased or same", oB >= cB);
                }
                else {
-                    assertTrue(oB <= cB, "Contrast should be increased or same");
+                    assertTrue("Contrast should be increased or same", oB <= cB);
                }
            }
        }
@@ -357,7 +357,7 @@ public class ImageUtilTest {
                int r = rgb >> 16 & 0xFF;
                int g = rgb >> 8 & 0xFF;
                int b = rgb & 0xFF;
-                assertTrue(r == 127 && g == 127 && b == 127, "Minimum contrast should be all gray");
+                assertTrue("Minimum contrast should be all gray", r == 127 && g == 127 && b == 127);
            }
        }

@@ -400,7 +400,7 @@ public class ImageUtilTest {
        if (original != notSharpened) { // Don't care to test if images are same
            for (int y = 0; y < original.getHeight(); y++) {
                for (int x = 0; x < original.getWidth(); x++) {
-                    assertEquals(original.getRGB(x, y), notSharpened.getRGB(x, y), "0 sharpen should not change image");
+                    assertEquals("0 sharpen should not change image", original.getRGB(x, y), notSharpened.getRGB(x, y));
                }
            }
        }
@@ -446,13 +446,13 @@ public class ImageUtilTest {
        }

 //        assertEquals("Difference should not change", diffOriginal, diffSharpened);
-        assertTrue(absDiffOriginal < absDiffSharpened, "Abs difference should increase");
+        assertTrue("Abs difference should increase", absDiffOriginal < absDiffSharpened);
 //        assertEquals("Difference should not change", diffOriginal, diffDefault);
-        assertTrue(absDiffOriginal < absDiffDefault, "Abs difference should increase");
+        assertTrue("Abs difference should increase", absDiffOriginal < absDiffDefault);
 //        assertEquals("Difference should not change", diffOriginal, diffMore);
-        assertTrue(absDiffOriginal < absDiffMore, "Abs difference should increase");
+        assertTrue("Abs difference should increase", absDiffOriginal < absDiffMore);
 //        assertEquals("Difference should not change", diffSharpened, diffMore);
-        assertTrue(absDiffSharpened < absDiffMore, "Abs difference should increase");
+        assertTrue("Abs difference should increase", absDiffSharpened < absDiffMore);
    }

    @Test
@@ -466,7 +466,7 @@ public class ImageUtilTest {
        if (original != notBlurred) { // Don't care to test if images are same
            for (int y = 0; y < original.getHeight(); y++) {
                for (int x = 0; x < original.getWidth(); x++) {
-                    assertEquals(original.getRGB(x, y), notBlurred.getRGB(x, y), "0 blur should not change image");
+                    assertEquals("0 blur should not change image", original.getRGB(x, y), notBlurred.getRGB(x, y));
                }
            }
        }
@@ -512,13 +512,13 @@ public class ImageUtilTest {
        }

 //        assertEquals("Difference should not change", diffOriginal, diffBlurred);
-        assertTrue(absDiffOriginal > absDiffBlurred, String.format("Abs difference should decrease: %s <= %s", absDiffOriginal, absDiffBlurred));
+        assertTrue(String.format("Abs difference should decrease: %s <= %s", absDiffOriginal, absDiffBlurred), absDiffOriginal > absDiffBlurred);
 //        assertEquals("Difference should not change", diffOriginal, diffDefault);
-        assertTrue(absDiffOriginal > absDiffDefault, "Abs difference should decrease");
+        assertTrue("Abs difference should decrease", absDiffOriginal > absDiffDefault);
 //        assertEquals("Difference should not change", diffOriginal, diffMore);
-        assertTrue(absDiffOriginal > absDiffMore, "Abs difference should decrease");
+        assertTrue("Abs difference should decrease", absDiffOriginal > absDiffMore);
 //        assertEquals("Difference should not change", diffBlurred, diffMore);
-        assertTrue(absDiffBlurred > absDiffMore, "Abs difference should decrease");
+        assertTrue("Abs difference should decrease", absDiffBlurred > absDiffMore);
    }

    @Test
@@ -528,7 +528,7 @@ public class ImageUtilTest {
        assertNotNull(sunflower);

        BufferedImage image = ImageUtil.createIndexed(sunflower);
-        assertNotNull(image, "Image was null");
-        assertInstanceOf(IndexColorModel.class, image.getColorModel());
+        assertNotNull("Image was null", image);
+        assertTrue(image.getColorModel() instanceof IndexColorModel);
    }
 }
@@ -30,8 +30,8 @@

 package com.twelvemonkeys.image;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
+import org.junit.Ignore;
+import org.junit.Test;

 import java.awt.*;
 import java.awt.image.BufferedImage;
@@ -40,7 +40,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * ResampleOpTestCase
@@ -124,7 +124,7 @@ public class ResampleOpTest {
            }
        }

-        assertEquals(Collections.EMPTY_LIST, exceptions, "Filter threw exceptions: ");
+        assertEquals("Filter threw exceptions: ", Collections.EMPTY_LIST, exceptions);
    }

    // 1x1
@@ -358,7 +358,7 @@ public class ResampleOpTest {
        }
    }

-    @Disabled("Not for general unit testing")
+    @Ignore("Not for general unit testing")
    @Test
    public void testTime() {
        int iterations = 1000;
@@ -0,0 +1,6 @@
+TODO:
+    Remove compile-time dependency on JMagick:
+        - Extract interface for MagickAccelerator
+        - Move implementation to separate module
+        - Instantiate impl via reflection
+DONE:
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>common-io</artifactId>
    <packaging>jar</packaging>
@@ -59,7 +59,7 @@ public final class DecoderStream extends FilterInputStream {
     * @see java.io.FilterInputStream#in
     */
    public DecoderStream(final InputStream stream, final Decoder decoder) {
-        // TODO: Let the decoder decide preferred buffer size
+        // TODO: Let the decoder decide preferred buffer size 
        this(stream, decoder, 1024);
    }

@@ -77,7 +77,7 @@ public final class DecoderStream extends FilterInputStream {
        super(stream);

        this.decoder = decoder;
-        buffer = ByteBuffer.allocate(bufferSize); // TODO: Allow decoder to specify minimum buffer size
+        buffer = ByteBuffer.allocate(bufferSize);
        buffer.flip();
    }

@@ -32,6 +32,7 @@ package com.twelvemonkeys.io;

 import com.twelvemonkeys.lang.StringUtil;
 import com.twelvemonkeys.util.CollectionUtil;
+import org.junit.Test;

 import java.io.IOException;
 import java.io.Reader;
@@ -39,8 +40,7 @@ import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.List;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * CompoundReaderTestCase
@@ -30,11 +30,12 @@

 package com.twelvemonkeys.io;

+import org.junit.Test;
+
 import java.io.IOException;
 import java.io.InputStream;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;

 /**
 * FastByteArrayOutputStreamTestCase
@@ -30,10 +30,11 @@

 package com.twelvemonkeys.io;

+import org.junit.Test;
+
 import java.io.*;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * MemoryCacheSeekableStreamTestCase
@@ -91,13 +92,13 @@ public class FileSeekableStreamTest extends SeekableInputStreamAbstractTest {
        try {
            FileUtil.read(stream); // Read until EOF

-            assertEquals(-1, stream.read(), "EOF not reached (test case broken)");
-            assertFalse(closed[0], "Underlying stream closed before close");
+            assertEquals("EOF not reached (test case broken)", -1, stream.read());
+            assertFalse("Underlying stream closed before close", closed[0]);
        }
        finally {
            stream.close();
        }

-        assertTrue(closed[0], "Underlying stream not closed");
+        assertTrue("Underlying stream not closed", closed[0]);
    }
 }
@@ -46,14 +46,14 @@
 package com.twelvemonkeys.io;

 import com.twelvemonkeys.lang.ObjectAbstractTest;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Random;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * InputStreamAbstractTestCase
@@ -104,15 +104,15 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
        int size = 5;
        InputStream input = makeInputStream(makeOrderedArray(size));
        for (int i = 0; i < size; i++) {
-            assertTrue((size - i) >= input.available(), "Check Size [" + i + "]");
-            assertEquals(i, input.read(), "Check Value [" + i + "]");
+            assertTrue("Check Size [" + i + "]", (size - i) >= input.available());
+            assertEquals("Check Value [" + i + "]", i, input.read());
        }
-        assertEquals(0, input.available(), "Available after contents all read");
+        assertEquals("Available after contents all read", 0, input.available());

        // Test reading after the end of file
        try {
            int result = input.read();
-            assertEquals( -1, result, "Wrong value read after end of file");
+            assertEquals("Wrong value read after end of file", -1, result);
        }
        catch (IOException e) {
            fail("Should not have thrown an IOException: " + e.getMessage());
@@ -122,12 +122,12 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
    @Test
    public void testAvailable() throws Exception {
        InputStream input = makeInputStream(1);
-        assertFalse(input.read() < 0, "Unexpected EOF");
-        assertEquals(0, input.available(), "Available after contents all read");
+        assertFalse("Unexpected EOF", input.read() < 0);
+        assertEquals("Available after contents all read", 0, input.available());

        // Check availbale is zero after End of file
-        assertEquals(-1, input.read(), "End of File");
-        assertEquals( 0, input.available(), "Available after End of File");
+        assertEquals("End of File", -1, input.read());
+        assertEquals("Available after End of File", 0, input.available());
    }

    @Test
@@ -138,26 +138,26 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {

        // Read into array
        int count1 = input.read(bytes);
-        assertEquals(bytes.length, count1, "Read 1");
+        assertEquals("Read 1", bytes.length, count1);
        for (int i = 0; i < count1; i++) {
-            assertEquals(i, bytes[i], "Check Bytes 1");
+            assertEquals("Check Bytes 1", i, bytes[i]);
        }

        // Read into array
        int count2 = input.read(bytes);
-        assertEquals(5, count2, "Read 2");
+        assertEquals("Read 2", 5, count2);
        for (int i = 0; i < count2; i++) {
-            assertEquals(count1 + i, bytes[i], "Check Bytes 2");
+            assertEquals("Check Bytes 2", count1 + i, bytes[i]);
        }

        // End of File
        int count3 = input.read(bytes);
-        assertEquals(-1, count3, "Read 3 (EOF)");
+        assertEquals("Read 3 (EOF)", -1, count3);

        // Test reading after the end of file
        try {
            int result = input.read(bytes);
-            assertEquals(-1, result, "Wrong value read after end of file");
+            assertEquals("Wrong value read after end of file", -1, result);
        }
        catch (IOException e) {
            fail("Should not have thrown an IOException: " + e.getMessage());
@@ -170,20 +170,20 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
        int offset = 2;
        int lth = 4;
        int count5 = input.read(bytes, offset, lth);
-        assertEquals(lth, count5, "Read 5");
+        assertEquals("Read 5", lth, count5);
        for (int i = offset; i < lth; i++) {
-            assertEquals(i - offset, bytes[i], "Check Bytes 2");
+            assertEquals("Check Bytes 2", i - offset, bytes[i]);
        }
    }

    @Test
    public void testEOF() throws Exception {
        InputStream input = makeInputStream(makeOrderedArray(2));
-        assertEquals(0, input.read(), "Read 1");
-        assertEquals(1, input.read(), "Read 2");
-        assertEquals(-1, input.read(), "Read 3");
-        assertEquals(-1, input.read(), "Read 4");
-        assertEquals(-1, input.read(), "Read 5");
+        assertEquals("Read 1", 0, input.read());
+        assertEquals("Read 2", 1, input.read());
+        assertEquals("Read 3", -1, input.read());
+        assertEquals("Read 4", -1, input.read());
+        assertEquals("Read 5", -1, input.read());
    }

    @Test
@@ -205,7 +205,7 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
            fail("Should throw IOException");
        }
        catch (IOException e) {
-            assertTrue(e.getMessage().contains("reset"), "Wrong messge: " + e.getMessage());
+            assertTrue("Wrong messge: " + e.getMessage(), e.getMessage().contains("reset"));
        }
    }

@@ -223,10 +223,10 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
        // No mark may either throw exception, or reset to beginning of stream.
        try {
            input.reset();
-            assertEquals(0, input.read(), "Re-read of reset data should be same");
+            assertEquals("Re-read of reset data should be same", 0, input.read());
        }
        catch (Exception e) {
-            assertTrue(e.getMessage().contains("mark"), "Wrong no mark IOException message");
+            assertTrue("Wrong no mark IOException message", e.getMessage().contains("mark"));
        }
    }

@@ -249,7 +249,7 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {

        // Read further
        for (int i = 0; i < 3; i++) {
-            assertEquals((position + i), input.read(), "Read After Mark [" + i + "]");
+            assertEquals("Read After Mark [" + i + "]", (position + i), input.read());
        }

        // Reset
@@ -257,7 +257,7 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {

        // Read from marked position
        for (int i = 0; i < readlimit + 1; i++) {
-            assertEquals((position + i), input.read(), "Read After Reset [" + i + "]");
+            assertEquals("Read After Reset [" + i + "]", (position + i), input.read());
        }
    }

@@ -280,16 +280,16 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {

        // Read past marked position
        for (int i = 0; i < readlimit + 1; i++) {
-            assertEquals((position + i), input.read(), "Read After Reset [" + i + "]");
+            assertEquals("Read After Reset [" + i + "]", (position + i), input.read());
        }

        // Reset after read limit passed, may either throw exception, or reset to last mark
        try {
            input.reset();
-            assertEquals(1, input.read(), "Re-read of reset data should be same");
+            assertEquals("Re-read of reset data should be same", 1, input.read());
        }
        catch (Exception e) {
-            assertTrue(e.getMessage().contains("mark"), "Wrong read-limit IOException message");
+            assertTrue("Wrong read-limit IOException message", e.getMessage().contains("mark"));
        }
    }

@@ -302,29 +302,29 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
        }

        int first = input.read();
-        assertTrue(first >= 0, "Expected to read positive value");
+        assertTrue("Expected to read positive value", first >= 0);

        int readlimit = 5;

        // Mark
        input.mark(readlimit);
        int read = input.read();
-        assertTrue(read >= 0, "Expected to read positive value");
+        assertTrue("Expected to read positive value", read >= 0);

        assertTrue(input.read() >= 0);
        assertTrue(input.read() >= 0);

        input.reset();
-        assertEquals(read, input.read(), "Expected value read differs from actual");
+        assertEquals("Expected value read differs from actual", read, input.read());

        // Reset after read limit passed, may either throw exception, or reset to last good mark
        try {
            input.reset();
            int reRead = input.read();
-            assertTrue(reRead == read || reRead == first, "Re-read of reset data should be same as initially marked or first");
+            assertTrue("Re-read of reset data should be same as initially marked or first", reRead == read || reRead == first);
        }
        catch (Exception e) {
-            assertTrue(e.getMessage().contains("mark"), "Wrong read-limit IOException message");
+            assertTrue("Wrong read-limit IOException message", e.getMessage().contains("mark"));
        }
    }

@@ -332,17 +332,17 @@ public abstract class InputStreamAbstractTest extends ObjectAbstractTest {
    public void testSkip() throws Exception {
        InputStream input = makeInputStream(makeOrderedArray(10));

-        assertEquals(0, input.read(), "Unexpected value read");
-        assertEquals(1, input.read(), "Unexpected value read");
-        assertEquals(5, input.skip(5), "Unexpected number of bytes skipped");
-        assertEquals(7, input.read(), "Unexpected value read");
+        assertEquals("Unexpected value read", 0, input.read());
+        assertEquals("Unexpected value read", 1, input.read());
+        assertEquals("Unexpected number of bytes skipped", 5, input.skip(5));
+        assertEquals("Unexpected value read", 7, input.read());

-        assertEquals(2, input.skip(5), "Unexpected number of bytes skipped"); // only 2 left to skip
-        assertEquals(-1, input.read(), "Unexpected value read after EOF");
+        assertEquals("Unexpected number of bytes skipped", 2, input.skip(5)); // only 2 left to skip
+        assertEquals("Unexpected value read after EOF", -1, input.read());

        // Spec says skip might return 0 or negative after EOF...
-        assertTrue(input.skip(5) <= 0, "Positive value skipped after EOF"); // End of file
-        assertEquals(-1, input.read(), "Unexpected value read after EOF");
+        assertTrue("Positive value skipped after EOF", input.skip(5) <= 0); // End of file
+        assertEquals("Unexpected value read after EOF", -1, input.read());
    }

    @Test
@@ -30,11 +30,12 @@

 package com.twelvemonkeys.io;

+import org.junit.Test;
+
 import java.io.ByteArrayInputStream;
 import java.io.IOException;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * LittleEndianDataInputStreamTest
@@ -31,12 +31,13 @@
 package com.twelvemonkeys.io;

 import com.twelvemonkeys.lang.ObjectAbstractTest;
+import org.junit.Test;

 import java.io.IOException;
 import java.io.OutputStream;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;

 /**
 * InputStreamAbstractTestCase
@@ -31,12 +31,12 @@
 package com.twelvemonkeys.io;

 import com.twelvemonkeys.lang.ObjectAbstractTest;
+import org.junit.Test;

 import java.io.IOException;
 import java.io.Reader;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * ReaderAbstractTestCase
@@ -112,7 +112,7 @@ public abstract class ReaderAbstractTest extends ObjectAbstractTest {
        int toSkip = mInput.length();
        while (toSkip > 0) {
            long skipped = reader.skip(toSkip);
-            assertFalse(skipped < 0, "Skipped < 0");
+            assertFalse("Skipped < 0", skipped < 0);
            toSkip -= skipped;
        }

@@ -30,8 +30,10 @@

 package com.twelvemonkeys.io;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;

 /**
 * SeekableAbstractTestCase
@@ -30,13 +30,14 @@

 package com.twelvemonkeys.io;

+import org.junit.Test;
+
 import java.io.ByteArrayInputStream;
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * SeekableInputStreamAbstractTest
@@ -78,25 +79,25 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac
            return; // Not supported, skip test
        }

-        assertTrue(input.read() >= 0, "Expected to read positive value");
+        assertTrue("Expected to read positive value", input.read() >= 0);

        int readlimit = 5;

        // Mark
        input.mark(readlimit);
        int read = input.read();
-        assertTrue(read >= 0, "Expected to read positive value");
+        assertTrue("Expected to read positive value", read >= 0);

        input.reset();
-        assertEquals(read, input.read(), "Expected value read differs from actual");
+        assertEquals("Expected value read differs from actual", read, input.read());

        // Reset after read limit passed, may either throw exception, or reset to last good mark
        try {
            input.reset();
-            assertEquals(0, input.read(), "Re-read of reset data should be first");
+            assertEquals("Re-read of reset data should be first", 0, input.read());
        }
        catch (Exception e) {
-            assertTrue(e.getMessage().contains("mark"), "Wrong read-limit IOException message");
+            assertTrue("Wrong read-limit IOException message", e.getMessage().contains("mark"));
        }
    }

@@ -126,7 +127,7 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac

        seekable.seek(pos);
        long streamPos = seekable.getStreamPosition();
-        assertEquals(pos, streamPos, "Stream positon should match seeked position");
+        assertEquals("Stream positon should match seeked position", pos, streamPos);
    }

    @Test
@@ -136,7 +137,7 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac
        seekable.seek(pos);
        seekable.flushBefore(pos);
        long flushedPos = seekable.getFlushedPosition();
-        assertEquals(pos, flushedPos, "Flushed positon should match position");
+        assertEquals("Flushed positon should match position", pos, flushedPos);

        try {
            seekable.seek(pos - 1);
@@ -381,13 +382,13 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac
        int val;

        val = stream.read();
-        assertFalse(val == -1, "Unexepected EOF");
+        assertFalse("Unexepected EOF", val == -1);
        val = stream.read();
-        assertFalse(val == -1, "Unexepected EOF");
+        assertFalse("Unexepected EOF", val == -1);
        val = stream.read();
-        assertFalse(val == -1, "Unexepected EOF");
+        assertFalse("Unexepected EOF", val == -1);
        val = stream.read();
-        assertFalse(val == -1, "Unexepected EOF");
+        assertFalse("Unexepected EOF", val == -1);

        stream.seek(0);

@@ -421,19 +422,19 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac

        stream.seek(0);
        for (int i = 0; i < bytes.length; i += 2) {
-            assertEquals(i, stream.getStreamPosition(), "Wrong stream position");
+            assertEquals("Wrong stream position", i, stream.getStreamPosition());
            int count = stream.read(buffer, 0, 2);
            assertEquals(2, count);
-            assertEquals(bytes[i], buffer[0], String.format("Wrong value read at pos %d", stream.getStreamPosition()));
-            assertEquals(bytes[i + 1], buffer[1], String.format("Wrong value read at pos %d", stream.getStreamPosition()));
+            assertEquals(String.format("Wrong value read at pos %d", stream.getStreamPosition()), bytes[i], buffer[0]);
+            assertEquals(String.format("Wrong value read at pos %d", stream.getStreamPosition()), bytes[i + 1], buffer[1]);
        }

        stream.seek(0);
        for (int i = 0; i < bytes.length; i++) {
-            assertEquals(i, stream.getStreamPosition(), "Wrong stream position");
+            assertEquals("Wrong stream position", i, stream.getStreamPosition());
            int actual = stream.read();
-            assertEquals(bytes[i] & 0xff, actual, String.format("Wrong value read at pos %d", stream.getStreamPosition()));
-            assertEquals(bytes[i], (byte) actual, String.format("Wrong value read at pos %d", stream.getStreamPosition()));
+            assertEquals(String.format("Wrong value read at pos %d", stream.getStreamPosition()), bytes[i] & 0xff, actual);
+            assertEquals(String.format("Wrong value read at pos %d", stream.getStreamPosition()), bytes[i], (byte) actual);
        }

    }
@@ -455,14 +456,14 @@ public abstract class SeekableInputStreamAbstractTest extends InputStreamAbstrac
        try {
            FileUtil.read(stream); // Read until EOF

-            assertEquals(-1, stream.read(), "EOF not reached (test case broken)");
-            assertFalse(closed[0], "Underlying stream closed before close");
+            assertEquals("EOF not reached (test case broken)", -1, stream.read());
+            assertFalse("Underlying stream closed before close", closed[0]);
        }
        finally {
            stream.close();
        }

-        assertTrue(closed[0], "Underlying stream not closed");
+        assertTrue("Underlying stream not closed", closed[0]);

    }

@@ -31,12 +31,12 @@
 package com.twelvemonkeys.io;

 import com.twelvemonkeys.lang.StringUtil;
+import org.junit.Test;

 import java.io.IOException;
 import java.io.Reader;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * StringArrayReaderTestCase
@@ -1,14 +1,15 @@
 package com.twelvemonkeys.io;

+import org.junit.Test;
+
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.time.Duration;
 import java.util.Arrays;
 import java.util.Random;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;

 /**
 * SubStreamTest.
@@ -22,18 +23,14 @@ public class SubStreamTest {
    private final Random rng = new Random(2918475687L);

    @SuppressWarnings("resource")
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNullStream() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new SubStream(null, 42);
-        });
+        new SubStream(null, 42);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNegativeLength() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new SubStream(new ByteArrayInputStream(new byte[1]), -1);
-        });
+        new SubStream(new ByteArrayInputStream(new byte[1]), -1);
    }

    @Test
@@ -103,17 +100,15 @@ public class SubStreamTest {
    }

    @SuppressWarnings("EmptyTryBlock")
-    @Test
+    @Test(timeout = 500L)
    public void testCloseConsumesAllShortStream() throws IOException {
-        assertTimeoutPreemptively(Duration.ofMillis(500), () -> {
-            ByteArrayInputStream stream = new ByteArrayInputStream(new byte[13]);
+        ByteArrayInputStream stream = new ByteArrayInputStream(new byte[13]);

-            try (InputStream ignore = new SubStream(stream, 42)) {
-                // Nothing here...
-            }
+        try (InputStream ignore = new SubStream(stream, 42)) {
+            // Nothing here...
+        }

-            assertEquals(0, stream.available());
-            assertEquals(-1, stream.read());
-        });
+        assertEquals(0, stream.available());
+        assertEquals(-1, stream.read());
    }
 }
@@ -31,13 +31,15 @@
 package com.twelvemonkeys.io.enc;

 import com.twelvemonkeys.io.FileUtil;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+
+import static org.junit.Assert.assertEquals;
+
 /**
 * Base64DecoderTest
 * <p/>
@@ -64,7 +66,7 @@ public class Base64DecoderTest extends DecoderAbstractTest {

        FileUtil.copy(in, bytes);

-        assertEquals("", new String(bytes.toByteArray()), "Strings does not match");
+        assertEquals("Strings does not match", "", new String(bytes.toByteArray()));
    }

    @Test
@@ -76,7 +78,7 @@ public class Base64DecoderTest extends DecoderAbstractTest {

        FileUtil.copy(in, bytes);

-        assertEquals("test", new String(bytes.toByteArray()), "Strings does not match");
+        assertEquals("Strings does not match", "test", new String(bytes.toByteArray()));
    }

    @Test
@@ -91,12 +93,11 @@ public class Base64DecoderTest extends DecoderAbstractTest {

        FileUtil.copy(in, bytes);

-        assertEquals(
+        assertEquals("Strings does not match",
                     "Lorem ipsum dolor sit amet, consectetuer adipiscing " +
                     "elit. Fusce est. Morbi luctus consectetuer justo. Vivamus " +
                     "dapibus laoreet purus. Nunc viverra dictum nisl. Integer " +
                     "ullamcorper, nisi in dictum amet.",
-                     new String(bytes.toByteArray()),
-                    "Strings does not match");
+                     new String(bytes.toByteArray()));
    }
 }
@@ -30,12 +30,13 @@

 package com.twelvemonkeys.io.enc;

+import org.junit.Test;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+
+import static org.junit.Assert.assertEquals;

 /**
 * Base64EncoderTest
@@ -62,7 +63,7 @@ public class Base64EncoderTest extends EncoderAbstractTest {
        OutputStream out = new EncoderStream(bytes, createEncoder(), true);
        out.write(data.getBytes());

-        assertEquals("", new String(bytes.toByteArray()), "Strings does not match");
+        assertEquals("Strings does not match", "", new String(bytes.toByteArray()));
    }

    @Test
@@ -73,7 +74,7 @@ public class Base64EncoderTest extends EncoderAbstractTest {
        OutputStream out = new EncoderStream(bytes, createEncoder(), true);
        out.write(data.getBytes());

-        assertEquals("dGVzdA==", new String(bytes.toByteArray()), "Strings does not match");
+        assertEquals("Strings does not match", "dGVzdA==", new String(bytes.toByteArray()));
    }

    @Test
@@ -87,12 +88,11 @@ public class Base64EncoderTest extends EncoderAbstractTest {
        OutputStream out = new EncoderStream(bytes, createEncoder(), true);
        out.write(data.getBytes());

-        assertEquals(
+        assertEquals("Strings does not match",
                     "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVlciBhZGlwaXNjaW5nIGVsaXQuIEZ1" +
                    "c2NlIGVzdC4gTW9yYmkgbHVjdHVzIGNvbnNlY3RldHVlciBqdXN0by4gVml2YW11cyBkYXBpYnVzIGxh" +
                    "b3JlZXQgcHVydXMuIE51bmMgdml2ZXJyYSBkaWN0dW0gbmlzbC4gSW50ZWdlciB1bGxhbWNvcnBlciwg" +
                    "bmlzaSBpbiBkaWN0dW0gYW1ldC4=",
-                     new String(bytes.toByteArray()),
-                "Strings does not match");
+                     new String(bytes.toByteArray()));
    }
 }
@@ -32,13 +32,12 @@ package com.twelvemonkeys.io.enc;

 import com.twelvemonkeys.io.FileUtil;
 import com.twelvemonkeys.lang.ObjectAbstractTest;
+import org.junit.Test;

-import java.awt.image.ImageProducer;
 import java.io.*;
 import java.nio.ByteBuffer;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * AbstractDecoderTest
@@ -56,13 +55,13 @@ public abstract class DecoderAbstractTest extends ObjectAbstractTest {
        return createDecoder();
    }

-    @Test
+    @Test(expected = NullPointerException.class)
    public final void testNullDecode() throws IOException {
        Decoder decoder = createDecoder();
        ByteArrayInputStream bytes = new ByteArrayInputStream(new byte[20]);
-        assertThrows(NullPointerException.class, () -> {
-            decoder.decode(bytes, null);
-        });
+
+        decoder.decode(bytes, null);
+        fail("null should throw NullPointerException");
    }

    @Test
@@ -72,7 +71,7 @@ public abstract class DecoderAbstractTest extends ObjectAbstractTest {

        try {
            int count = decoder.decode(bytes, ByteBuffer.allocate(128));
-            assertEquals( 0, count, "Should not be able to read any bytes");
+            assertEquals("Should not be able to read any bytes", 0, count);
        }
        catch (EOFException allowed) {
            // Okay
@@ -95,7 +94,7 @@ public abstract class DecoderAbstractTest extends ObjectAbstractTest {
        byte[] encoded = outBytes.toByteArray();

        byte[] decoded = FileUtil.read(new DecoderStream(new ByteArrayInputStream(encoded), createDecoder()));
-        assertArrayEquals(data, decoded, String.format("Data %d", pLength));
+        assertArrayEquals(String.format("Data %d", pLength), data, decoded);

        InputStream in = new DecoderStream(new ByteArrayInputStream(encoded), createDecoder());
        outBytes = new ByteArrayOutputStream();
@@ -104,7 +103,7 @@ public abstract class DecoderAbstractTest extends ObjectAbstractTest {
        in.close();

        decoded = outBytes.toByteArray();
-        assertArrayEquals(data, decoded, String.format("Data %d", pLength));
+        assertArrayEquals(String.format("Data %d", pLength), data, decoded);
    }

    @Test
@@ -30,6 +30,7 @@

 package com.twelvemonkeys.io.enc;

+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -38,8 +39,7 @@ import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.Random;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 public class DecoderStreamTest {

@@ -33,12 +33,13 @@ package com.twelvemonkeys.io.enc;
 import com.twelvemonkeys.io.FileUtil;
 import com.twelvemonkeys.lang.ObjectAbstractTest;

+import org.junit.Test;

 import java.io.*;
 import java.util.Random;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.fail;

 /**
 * AbstractEncoderTest
@@ -30,6 +30,8 @@

 package com.twelvemonkeys.io.enc;

+import org.junit.Test;
+
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -37,8 +39,7 @@ import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.Random;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;

 public class EncoderStreamTest {

@@ -31,9 +31,9 @@
 package com.twelvemonkeys.io.ole2;

 import com.twelvemonkeys.io.MemoryCacheSeekableStream;
+import org.junit.Test;

 import javax.imageio.stream.MemoryCacheImageInputStream;
-import java.awt.image.ImageProducer;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -43,8 +43,8 @@ import java.nio.ByteOrder;
 import java.util.SortedSet;
 import java.util.TreeSet;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
+
 /**
 * CompoundDocumentTestCase
 *
@@ -59,8 +59,8 @@ public class CompoundDocumentTest {
    protected final CompoundDocument createTestDocument() throws IOException {
        URL input = getClass().getResource(SAMPLE_DATA);

-        assertNotNull(input, "Missing test resource!");
-        assertEquals( "file", input.getProtocol(), "Test resource not a file:// resource");
+        assertNotNull("Missing test resource!", input);
+        assertEquals("Test resource not a file:// resource", "file", input.getProtocol());

        try {
            return new CompoundDocument(new File(input.toURI()));
@@ -103,7 +103,7 @@ public class CompoundDocumentTest {
        }
    }

-    @Test
+    @Test(expected = UnsupportedOperationException.class)
    public void testChildEntriesUnmodifiable() throws IOException {
        try (CompoundDocument document = createTestDocument()) {
            Entry root = document.getRootEntry();
@@ -111,10 +111,9 @@ public class CompoundDocumentTest {
            assertNotNull(root);

            SortedSet<Entry> children = root.getChildEntries();
-            assertThrows(UnsupportedOperationException.class, () -> {
-                // Should not be allowed, as it modifies the internal structure
-                children.remove(children.first());
-            });
+
+            // Should not be allowed, as it modifies the internal structure
+            children.remove(children.first());
        }
    }

@@ -129,7 +128,7 @@ public class CompoundDocumentTest {
            Entry catalog = root.getChildEntry("Catalog");

            assertNotNull(catalog);
-            assertNotNull(catalog.getInputStream(), "Input stream may not be null");
+            assertNotNull("Input stream may not be null", catalog.getInputStream());
        }
    }

@@ -137,7 +136,7 @@ public class CompoundDocumentTest {
    public void testReadCatalogInputStream() throws IOException {
        InputStream input = getClass().getResourceAsStream(SAMPLE_DATA);

-        assertNotNull(input, "Missing test resource!");
+        assertNotNull("Missing test resource!", input);

        CompoundDocument document = new CompoundDocument(input);
        Entry root = document.getRootEntry();
@@ -146,14 +145,14 @@ public class CompoundDocumentTest {

        Entry catalog = root.getChildEntry("Catalog");
        assertNotNull(catalog);
-        assertNotNull(catalog.getInputStream(), "Input stream may not be null");
+        assertNotNull("Input stream may not be null", catalog.getInputStream());
    }

    @Test
    public void testReadCatalogSeekableStream() throws IOException {
        InputStream input = getClass().getResourceAsStream(SAMPLE_DATA);

-        assertNotNull(input, "Missing test resource!");
+        assertNotNull("Missing test resource!", input);

        CompoundDocument document = new CompoundDocument(new MemoryCacheSeekableStream(input));
        Entry root = document.getRootEntry();
@@ -162,14 +161,14 @@ public class CompoundDocumentTest {

        Entry catalog = root.getChildEntry("Catalog");
        assertNotNull(catalog);
-        assertNotNull(catalog.getInputStream(), "Input stream may not be null");
+        assertNotNull("Input stream may not be null", catalog.getInputStream());
    }

    @Test
    public void testReadCatalogImageInputStream() throws IOException {
        InputStream input = getClass().getResourceAsStream(SAMPLE_DATA);

-        assertNotNull(input, "Missing test resource!");
+        assertNotNull("Missing test resource!", input);

        MemoryCacheImageInputStream stream = new MemoryCacheImageInputStream(input);
        stream.setByteOrder(ByteOrder.LITTLE_ENDIAN);
@@ -184,6 +183,6 @@ public class CompoundDocumentTest {
        Entry catalog = root.getChildEntry("Catalog");

        assertNotNull(catalog);
-        assertNotNull(catalog.getInputStream(), "Input stream may not be null");
+        assertNotNull("Input stream may not be null", catalog.getInputStream());
    }
 }
@@ -31,7 +31,7 @@
 package com.twelvemonkeys.io.ole2;

 import com.twelvemonkeys.io.*;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;

@@ -33,6 +33,7 @@ package com.twelvemonkeys.io.ole2;
 import com.twelvemonkeys.io.InputStreamAbstractTest;
 import com.twelvemonkeys.io.LittleEndianDataOutputStream;
 import com.twelvemonkeys.io.MemoryCacheSeekableStream;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -41,8 +42,7 @@ import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * CompoundDocument_StreamTestCase
@@ -165,8 +165,8 @@ public class CompoundDocument_StreamTest extends InputStreamAbstractTest {
            count++;
        }

-        assertFalse(count < 32, "Short stream");
-        assertFalse(count > 32, "Stream overrun");
+        assertFalse("Short stream", count < 32);
+        assertFalse("Stream overrun", count > 32);
    }

    @Test
@@ -30,8 +30,9 @@

 package com.twelvemonkeys.net;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;

 /**
 * HTTPUtilTest
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.common</groupId>
        <artifactId>common</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>common-lang</artifactId>
    <packaging>jar</packaging>
@@ -1765,11 +1765,12 @@ public final class StringUtil {
     * expression.
     * <p>
     * An invocation of this method of the form
-     * {@code matches(str, regex)} yields exactly the
+     * <tt>matches(<i>str</i>, <i>regex</i>)</tt> yields exactly the
     * same result as the expression
     * </p>
-     * <blockquote>{@link Pattern}.
-     * {@link Pattern#matches(String, CharSequence) matches(regex, str)}</blockquote>
+     * <blockquote><tt> {@link Pattern}.
+     * {@link Pattern#matches(String, CharSequence) matches}
+     * (<i>regex</i>, <i>str</i>)</tt></blockquote>
     *
     * @param pString the string
     * @param pRegex  the regular expression to which this string is to be matched
@@ -1788,14 +1789,16 @@ public final class StringUtil {
     * regular expression with the given pReplacement.
     * <p>
     * An invocation of this method of the form
-     * {@code replaceFirst(str, regex, repl)}
+     * <tt>
+     *     replaceFirst(<i>str</i>, <i>regex</i>, <i>repl</i>)
+     * </tt>
     * yields exactly the same result as the expression:
     * </p>
-     * <blockquote>
-     * {@link Pattern#compile(String) Pattern.compile(regex)}
-     * {@link Pattern#matcher .matcher(str)}
-     * {@link java.util.regex.Matcher#replaceFirst .replaceFirst(repl)}
-     * </blockquote>
+     * <blockquote><tt>
+     * {@link Pattern}.{@link Pattern#compile(String) compile}(<i>regex</i>).
+     * {@link Pattern#matcher matcher}(<i>str</i>).
+     * {@link java.util.regex.Matcher#replaceFirst replaceFirst}(<i>repl</i>)
+     * </tt></blockquote>
     *
     * @param pString      the string
     * @param pRegex       the regular expression to which this string is to be matched
@@ -1814,14 +1817,14 @@ public final class StringUtil {
     * regular expression with the given pReplacement.
     * <p>
     * An invocation of this method of the form
-     * {@code replaceAll(str, pRegex, repl)}
+     * <tt>replaceAll(<i>str</i>, <i>pRegex</i>, <i>repl</i>)</tt>
     * yields exactly the same result as the expression
     * </p>
-     * <blockquote>
-     * {@link Pattern#compile(String) Pattern.compile(pRegex)}
-     * {@link Pattern#matcher .matcher(str)}
-     * {@link java.util.regex.Matcher#replaceAll .replaceAll(repl)}
-     * </blockquote>
+     * <blockquote><tt>
+     * {@link Pattern}.{@link Pattern#compile(String) compile}(<i>pRegex</i>).
+     * {@link Pattern#matcher matcher}(<i>str</i>{@code ).
+     * {@link java.util.regex.Matcher#replaceAll replaceAll}(}<i>repl</i>{@code )}
+     * </tt></blockquote>
     *
     * @param pString      the string
     * @param pRegex       the regular expression to which this string is to be matched
@@ -1859,12 +1862,12 @@ public final class StringUtil {
     * </p>
     * <p>
     * An invocation of this method of the form
-     * {@code split(str, regex, n)}
+     * <tt>split(<i>str</i>, <i>regex</i>, <i>n</i>)</tt>
     * yields the same result as the expression:
     * </p>
     * <blockquote>{@link Pattern}.
-     * {@link Pattern#compile(String) compile(regex)}.
-     * {@link Pattern#split(CharSequence,int) split(str, n)}
+     * {@link Pattern#compile(String) compile}<tt>(<i>regex</i>).
+     * {@link Pattern#split(CharSequence,int) split}(<i>str</i>, <i>n</i>)</tt>
     * </blockquote>
     *
     * @param pString the string
@@ -30,13 +30,14 @@

 package com.twelvemonkeys.lang;

+import org.junit.Test;
+
 import java.io.Serializable;
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * BeanUtilTestCase
@@ -160,8 +161,10 @@ public class BeanUtilTest {
        }

        assertNotNull(bean.getAmbiguous());
-        assertEquals("one", bean.getAmbiguous(), "String converted rather than invoking setAmbiguous(String), ordering not predictable");
-        assertSame(value, bean.getAmbiguous(), "String converted rather than invoking setAmbiguous(String), ordering not predictable");
+        assertEquals("String converted rather than invoking setAmbiguous(String), ordering not predictable",
+                     "one", bean.getAmbiguous());
+        assertSame("String converted rather than invoking setAmbiguous(String), ordering not predictable",
+                   value, bean.getAmbiguous());
    }

    @Test
@@ -181,10 +184,10 @@ public class BeanUtilTest {
        }

        assertNotNull(bean.getAmbiguous());
-        assertEquals(2, bean.getAmbiguous(),
-                "Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable");
-        assertSame(value, bean.getAmbiguous(),
-                "Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable");
+        assertEquals("Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable",
+                2, bean.getAmbiguous());
+        assertSame("Integer converted rather than invoking setAmbiguous(Integer), ordering not predictable",
+                   value, bean.getAmbiguous());
    }

    @Test
@@ -204,8 +207,10 @@ public class BeanUtilTest {
        }

        assertNotNull(bean.getAmbiguous());
-        assertEquals(value.getClass(), bean.getAmbiguous().getClass(), "Object converted rather than invoking setAmbiguous(Object), ordering not predictable");
-        assertSame(value, bean.getAmbiguous(), "Object converted rather than invoking setAmbiguous(Object), ordering not predictable");
+        assertEquals("Object converted rather than invoking setAmbiguous(Object), ordering not predictable",
+                     value.getClass(), bean.getAmbiguous().getClass());
+        assertSame("Object converted rather than invoking setAmbiguous(Object), ordering not predictable",
+                   value, bean.getAmbiguous());
    }

    static class TestBean {
@@ -30,16 +30,16 @@

 package com.twelvemonkeys.lang;

+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.List;
 import java.util.TimeZone;

-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;

 /**
 * DateUtilTest
@@ -48,9 +48,12 @@ import static org.junit.jupiter.api.Assertions.*;
 * @author last modified by $Author: haraldk$
 * @version $Id: DateUtilTest.java,v 1.0 11.04.12 16:21 haraldk Exp$
 */
-
+@RunWith(Parameterized.class)
 public class DateUtilTest {

+    private final TimeZone timeZone;
+
+    @Parameterized.Parameters
    public static List<Object[]> timeZones() {
        return Arrays.asList(new Object[][] {
                {TimeZone.getTimeZone("UTC")},
@@ -59,6 +62,10 @@ public class DateUtilTest {
        });
    }

+    public DateUtilTest(final TimeZone timeZone) {
+        this.timeZone = timeZone;
+    }
+
    private Calendar getCalendar(long time) {
        return getCalendar(time, TimeZone.getDefault());
    }
@@ -94,9 +101,8 @@ public class DateUtilTest {
        assertEquals(0, calendar.get(Calendar.MINUTE));
    }

-    @ParameterizedTest
-    @MethodSource("timeZones")
-    public void testRoundToHourTZ(TimeZone timeZone) {
+    @Test
+    public void testRoundToHourTZ() {
        Calendar calendar = getCalendar(DateUtil.roundToHour(System.currentTimeMillis(), timeZone), timeZone);

        assertEquals(0, calendar.get(Calendar.MILLISECOND));
@@ -114,9 +120,8 @@ public class DateUtilTest {
        assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
    }

-    @ParameterizedTest
-    @MethodSource("timeZones")
-    public void testRoundToDayTZ(TimeZone timeZone) {
+    @Test
+    public void testRoundToDayTZ() {
        Calendar calendar = getCalendar(DateUtil.roundToDay(System.currentTimeMillis(), timeZone), timeZone);

        assertEquals(0, calendar.get(Calendar.MILLISECOND));
@@ -30,11 +30,12 @@

 package com.twelvemonkeys.lang;

+import org.junit.Test;
+
 import java.io.*;
 import java.lang.reflect.Method;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * AbstractObjectTestCase
@@ -78,10 +79,10 @@ public abstract class ObjectAbstractTest {

        Class cl = obj.getClass();
        if (isEqualsOverriden(cl)) {
-            assertTrue(isHashCodeOverriden(cl), "Class " + cl.getName() + " implements equals but not hashCode");
+            assertTrue("Class " + cl.getName() + " implements equals but not hashCode", isHashCodeOverriden(cl));
        }
        else if (isHashCodeOverriden(cl)) {
-            assertTrue(isEqualsOverriden(cl), "Class " + cl.getName() + " implements hashCode but not equals");
+            assertTrue("Class " + cl.getName() + " implements hashCode but not equals", isEqualsOverriden(cl));
        }

    }
@@ -106,7 +107,7 @@ public abstract class ObjectAbstractTest {
    @Test
    public void testObjectEqualsSelf() {
        Object obj = makeObject();
-        assertEquals(obj, obj, "An Object should equal itself");
+        assertEquals("An Object should equal itself", obj, obj);
    }

    @Test
@@ -114,26 +115,32 @@ public abstract class ObjectAbstractTest {
        Object obj = makeObject();
        // NOTE: Makes sure this doesn't throw NPE either
        //noinspection ObjectEqualsNull
-        assertFalse(obj.equals(null), "An object should never equal null");
+        assertFalse("An object should never equal null", obj.equals(null));
    }

    @Test
    public void testObjectHashCodeEqualsSelfHashCode() {
        Object obj = makeObject();
-        assertEquals(obj.hashCode(), obj.hashCode(), "hashCode should be repeatable");
+        assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
    }

    @Test
    public void testObjectHashCodeEqualsContract() {
        Object obj1 = makeObject();
        if (obj1.equals(obj1)) {
-            assertEquals(obj1.hashCode(), obj1.hashCode(), "[1] When two objects are equal, their hashCodes should be also.");
+            assertEquals(
+                "[1] When two objects are equal, their hashCodes should be also.",
+                obj1.hashCode(), obj1.hashCode());
        }
        // TODO: Make sure we create at least one equal object, and one different object
        Object obj2 = makeObject();
        if (obj1.equals(obj2)) {
-            assertEquals(obj1.hashCode(), obj2.hashCode(), "[2] When two objects are equal, their hashCodes should be also.");
-            assertTrue(obj2.equals(obj1), "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true");
+            assertEquals(
+                "[2] When two objects are equal, their hashCodes should be also.",
+                obj1.hashCode(), obj2.hashCode());
+            assertTrue(
+                "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
+                obj2.equals(obj1));
        }
    }

@@ -162,14 +169,14 @@ public abstract class ObjectAbstractTest {

            Object cloned = clone.invoke(obj);

-            assertNotNull(cloned, "Cloned object should never be null");
+            assertNotNull("Cloned object should never be null", cloned);

            // TODO: This can only be asserted if equals() test is based on
            // value equality, not reference (identity) equality
            // Maybe it's possible to do a reflective introspection of
            // the objects fields?
            if (isHashCodeOverriden(cl)) {
-                assertEquals(obj, cloned, "Cloned object not equal");
+                assertEquals("Cloned object not equal", obj, cloned);
            }
        }
    }
@@ -228,7 +235,7 @@ public abstract class ObjectAbstractTest {
            // Maybe it's possible to do a reflective introspection of
            // the objects fields?
            if (isEqualsOverriden(obj.getClass())) {
-                assertEquals(obj, dest, "obj != deserialize(serialize(obj))");
+                assertEquals("obj != deserialize(serialize(obj))", obj, dest);
            }
        }
    }
@@ -30,11 +30,13 @@

 package com.twelvemonkeys.lang;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import java.util.Properties;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;

 /**
 * PlatformTest
@@ -119,7 +121,7 @@ public class PlatformTest {
        assertEquals(Platform.Architecture.X86, platform.getArchitecture());
    }

-    @Disabled("Known issue, needs resolve")
+    @Ignore("Known issue, needs resolve")
    @Test
    public void testCreateWindows686() {
        Platform platform = new Platform(createProperties("Windows", "5.1", "686"));
@@ -127,7 +129,7 @@ public class PlatformTest {
        assertEquals(Platform.Architecture.X86, platform.getArchitecture());
    }

-    @Disabled("Known issue, needs resolve")
+    @Ignore("Known issue, needs resolve")
    @Test
    public void testCreateLinuxX86() {
        Platform platform = new Platform(createProperties("Linux", "3.0.18", "x86"));
@@ -30,6 +30,8 @@

 package com.twelvemonkeys.lang;

+import static org.junit.Assert.*;
+
 import java.awt.*;
 import java.sql.Timestamp;
 import java.text.DateFormat;
@@ -39,8 +41,8 @@ import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.Locale;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import org.junit.Test;
+
 /**
 * StringUtilTestCase
 *
@@ -163,10 +165,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if (TEST_STRING.indexOf(i) < 0) {
-                assertFalse(StringUtil.contains(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertFalse(TEST_STRING + " seems to contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.contains(TEST_STRING, i));
            }
            else {
-                assertTrue(StringUtil.contains(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.contains(TEST_STRING, i));
            }
        }
    }
@@ -197,10 +199,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
-                assertFalse(StringUtil.containsIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
+                assertFalse(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), StringUtil.containsIgnoreCase(TEST_STRING, i));
            }
            else {
-                assertTrue(StringUtil.containsIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), StringUtil.containsIgnoreCase(TEST_STRING, i));
            }
        }
    }
@@ -348,10 +350,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
-                assertEquals(-1, StringUtil.indexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
+                assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.indexOfIgnoreCase(TEST_STRING, i));
            }
            else {
-                assertTrue(0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i));
            }
        }
    }
@@ -383,10 +385,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
-                assertEquals(-1, StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
+                assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0));
            }
            else {
-                assertTrue(0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.indexOfIgnoreCase(TEST_STRING, i, 0));
            }
        }
    }
@@ -418,10 +420,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
-                assertEquals(-1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
+                assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i));
            }
            else {
-                assertTrue(0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i));
            }
        }
    }
@@ -453,10 +455,10 @@ public class StringUtilTest {
        // Test all alpha-chars
        for (int i = 'a'; i < 'z'; i++) {
            if ((TEST_STRING.indexOf(i) < 0) && (TEST_STRING.indexOf(Character.toUpperCase((char) i)) < 0)) {
-                assertEquals(-1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()), TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))));
+                assertEquals(TEST_STRING + " seems to contain '" + (char) i + "', at index " + Math.max(TEST_STRING.indexOf(i), TEST_STRING.indexOf(Character.toUpperCase((char) i))), -1, StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()));
            }
            else {
-                assertTrue(0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()), TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i));
+                assertTrue(TEST_STRING + " seems to not contain '" + (char) i + "', at index " + TEST_STRING.indexOf(i), 0 <= StringUtil.lastIndexOfIgnoreCase(TEST_STRING, i, TEST_STRING.length()));
            }
        }
    }
@@ -30,7 +30,7 @@

 package com.twelvemonkeys.lang;

-import org.junit.jupiter.api.Disabled;
+import org.junit.Ignore;

 /**
 * SystemUtilTest
@@ -39,6 +39,6 @@ import org.junit.jupiter.api.Disabled;
 * @author last modified by $Author: haraldk$
 * @version $Id: SystemUtilTest.java,v 1.0 11.04.12 16:21 haraldk Exp$
 */
-@Disabled
+@Ignore
 public class SystemUtilTest {
 }
@@ -45,11 +45,12 @@

 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.lang.reflect.Array;
 import java.util.*;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * Abstract test class for {@link java.util.Collection} methods and contracts.
@@ -250,8 +251,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
     */
    public void verifyAll() {
        int confirmedSize = confirmed.size();
-        assertEquals(confirmedSize, collection.size(), "Collection size should match confirmed collection's");
-        assertEquals(confirmed.isEmpty(), collection.isEmpty(), "Collection isEmpty() result should match confirmed  collection's");
+        assertEquals("Collection size should match confirmed collection's",
+                     confirmedSize, collection.size());
+        assertEquals("Collection isEmpty() result should match confirmed " +
+                     " collection's",
+                     confirmed.isEmpty(), collection.isEmpty());

        // verify the collections are the same by attempting to match each
        // object in the collection and confirmed collection.  To account for
@@ -517,8 +521,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
            boolean r = collection.add(elements[i]);
            confirmed.add(elements[i]);
            verifyAll();
-            assertTrue(r, "Empty collection changed after add");
-            assertEquals(1, collection.size(), "Collection size is 1 after first add");
+            assertTrue("Empty collection changed after add", r);
+            assertEquals("Collection size is 1 after first add", 1, collection.size());
        }

        resetEmpty();
@@ -528,8 +532,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
            confirmed.add(elements[i]);
            verifyAll();
            if (r) size++;
-            assertEquals(size, collection.size(), "Collection size should grow after add");
-            assertTrue(collection.contains(elements[i]), "Collection should contain added element");
+            assertEquals("Collection size should grow after add",
+                         size, collection.size());
+            assertTrue("Collection should contain added element",
+                       collection.contains(elements[i]));
        }
    }

@@ -546,9 +552,10 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        boolean r = collection.addAll(Arrays.asList(elements));
        confirmed.addAll(Arrays.asList(elements));
        verifyAll();
-        assertTrue(r, "Empty collection should change after addAll");
+        assertTrue("Empty collection should change after addAll", r);
        for (int i = 0; i < elements.length; i++) {
-            assertTrue(collection.contains(elements[i]), "Collection should contain added element");
+            assertTrue("Collection should contain added element",
+                       collection.contains(elements[i]));
        }

        resetFull();
@@ -557,11 +564,13 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        r = collection.addAll(Arrays.asList(elements));
        confirmed.addAll(Arrays.asList(elements));
        verifyAll();
-        assertTrue(r, "Full collection should change after addAll");
+        assertTrue("Full collection should change after addAll", r);
        for (int i = 0; i < elements.length; i++) {
-            assertTrue(collection.contains(elements[i]), "Full collection should contain added element");
+            assertTrue("Full collection should contain added element",
+                       collection.contains(elements[i]));
        }
-        assertEquals(size + elements.length, collection.size(), "Size should increase after addAll");
+        assertEquals("Size should increase after addAll",
+                     size + elements.length, collection.size());

        resetFull();
        size = collection.size();
@@ -569,9 +578,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        confirmed.addAll(Arrays.asList(getFullElements()));
        verifyAll();
        if (r) {
-            assertTrue(size < collection.size(), "Size should increase if addAll returns true");
+            assertTrue("Size should increase if addAll returns true",
+                       size < collection.size());
        } else {
-            assertEquals(size, collection.size(), "Size should not change if addAll returns false");
+            assertEquals("Size should not change if addAll returns false",
+                         size, collection.size());
        }
    }

@@ -655,14 +666,16 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetEmpty();
        elements = getFullElements();
        for(int i = 0; i < elements.length; i++) {
-            assertTrue(!collection.contains(elements[i]), "Empty collection shouldn't contain element[" + i + "]");
+            assertTrue("Empty collection shouldn't contain element[" + i + "]",
+                       !collection.contains(elements[i]));
        }
        // make sure calls to "contains" don't change anything
        verifyAll();

        elements = getOtherElements();
        for(int i = 0; i < elements.length; i++) {
-            assertTrue(!collection.contains(elements[i]), "Empty collection shouldn't contain element[" + i + "]");
+            assertTrue("Empty collection shouldn't contain element[" + i + "]",
+                       !collection.contains(elements[i]));
        }
        // make sure calls to "contains" don't change anything
        verifyAll();
@@ -670,7 +683,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetFull();
        elements = getFullElements();
        for(int i = 0; i < elements.length; i++) {
-            assertTrue(collection.contains(elements[i]), "Full collection should contain element[" + i + "]");
+            assertTrue("Full collection should contain element[" + i + "]",
+                       collection.contains(elements[i]));
        }
        // make sure calls to "contains" don't change anything
        verifyAll();
@@ -678,7 +692,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetFull();
        elements = getOtherElements();
        for(int i = 0; i < elements.length; i++) {
-            assertTrue(!collection.contains(elements[i]), "Full collection shouldn't contain element");
+            assertTrue("Full collection shouldn't contain element",
+                       !collection.contains(elements[i]));
        }
    }

@@ -690,22 +705,22 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    public void testCollectionContainsAll() {
        resetEmpty();
        Collection col = new HashSet();
-        assertTrue(collection.containsAll(col),
-                "Every Collection should contain all elements of an " +
-                        "empty Collection.");
+        assertTrue("Every Collection should contain all elements of an " +
+                   "empty Collection.", collection.containsAll(col));
        col.addAll(Arrays.asList(getOtherElements()));
-        assertTrue(!collection.containsAll(col),
-                "Empty Collection shouldn't contain all elements of " +
-                        "a non-empty Collection.");
+        assertTrue("Empty Collection shouldn't contain all elements of " +
+                   "a non-empty Collection.", !collection.containsAll(col));
        // make sure calls to "containsAll" don't change anything
        verifyAll();

        resetFull();
-        assertTrue(!collection.containsAll(col), "Full collection shouldn't contain other elements");
+        assertTrue("Full collection shouldn't contain other elements",
+                   !collection.containsAll(col));

        col.clear();
        col.addAll(Arrays.asList(getFullElements()));
-        assertTrue(collection.containsAll(col), "Full collection should containAll full elements");
+        assertTrue("Full collection should containAll full elements",
+                   collection.containsAll(col));
        // make sure calls to "containsAll" don't change anything
        verifyAll();

@@ -713,17 +728,18 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        int max = (getFullElements().length == 1 ? 1 :
                    (getFullElements().length <= 5 ? getFullElements().length - 1 : 5));
        col = Arrays.asList(getFullElements()).subList(min, max);
-        assertTrue(collection.containsAll(col), "Full collection should containAll partial full " +
-                "elements");
-        assertTrue(collection.containsAll(collection), "Full collection should containAll itself");
+        assertTrue("Full collection should containAll partial full " +
+                   "elements", collection.containsAll(col));
+        assertTrue("Full collection should containAll itself",
+                   collection.containsAll(collection));
        // make sure calls to "containsAll" don't change anything
        verifyAll();

        col = new ArrayList();
        col.addAll(Arrays.asList(getFullElements()));
        col.addAll(Arrays.asList(getFullElements()));
-        assertTrue(collection.containsAll(col), "Full collection should containAll duplicate full " +
-                "elements");
+        assertTrue("Full collection should containAll duplicate full " +
+                   "elements", collection.containsAll(col));

        // make sure calls to "containsAll" don't change anything
        verifyAll();
@@ -735,12 +751,14 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    @Test
    public void testCollectionIsEmpty() {
        resetEmpty();
-        assertEquals(true, collection.isEmpty(), "New Collection should be empty.");
+        assertEquals("New Collection should be empty.",
+                     true, collection.isEmpty());
        // make sure calls to "isEmpty() don't change anything
        verifyAll();

        resetFull();
-        assertEquals(false, collection.isEmpty(), "Full collection shouldn't be empty");
+        assertEquals("Full collection shouldn't be empty",
+                     false, collection.isEmpty());
        // make sure calls to "isEmpty() don't change anything
        verifyAll();
    }
@@ -753,7 +771,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    public void testCollectionIterator() {
        resetEmpty();
        Iterator it1 = collection.iterator();
-        assertEquals(false, it1.hasNext(), "Iterator for empty Collection shouldn't have next.");
+        assertEquals("Iterator for empty Collection shouldn't have next.",
+                     false, it1.hasNext());
        try {
            it1.next();
            fail("Iterator at end of Collection should throw " +
@@ -767,17 +786,18 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetFull();
        it1 = collection.iterator();
        for (int i = 0; i < collection.size(); i++) {
-            assertTrue(it1.hasNext(), "Iterator for full collection should haveNext");
+            assertTrue("Iterator for full collection should haveNext",
+                       it1.hasNext());
            it1.next();
        }
-        assertTrue(!it1.hasNext(), "Iterator should be finished");
+        assertTrue("Iterator should be finished", !it1.hasNext());

        ArrayList list = new ArrayList();
        it1 = collection.iterator();
        for (int i = 0; i < collection.size(); i++) {
            Object next = it1.next();
-            assertTrue(collection.contains(next), "Collection should contain element returned by " +
-                    "its iterator");
+            assertTrue("Collection should contain element returned by " +
+                       "its iterator", collection.contains(next));
            list.add(next);
        }
        try {
@@ -845,10 +865,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
            }

            size--;
-            assertEquals(size, collection.size(), "Collection should shrink by one after " +
-                    "iterator.remove");
+            assertEquals("Collection should shrink by one after " +
+                         "iterator.remove", size, collection.size());
        }
-        assertTrue(collection.isEmpty(), "Collection should be empty after iterator purge");
+        assertTrue("Collection should be empty after iterator purge",
+                   collection.isEmpty());

        resetFull();
        iter = collection.iterator();
@@ -873,7 +894,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetEmpty();
        Object[] elements = getFullElements();
        for (int i = 0; i < elements.length; i++) {
-            assertTrue(!collection.remove(elements[i]), "Shouldn't remove nonexistent element");
+            assertTrue("Shouldn't remove nonexistent element",
+                       !collection.remove(elements[i]));
            verifyAll();
        }

@@ -881,14 +903,16 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {

        resetFull();
        for (int i = 0; i < other.length; i++) {
-            assertTrue(!collection.remove(other[i]), "Shouldn't remove nonexistent other element");
+            assertTrue("Shouldn't remove nonexistent other element",
+                       !collection.remove(other[i]));
            verifyAll();
        }

        int size = collection.size();
        for (int i = 0; i < elements.length; i++) {
            resetFull();
-            assertTrue(collection.remove(elements[i]), "Collection should remove extant element: " + elements[i]);
+            assertTrue("Collection should remove extant element: " + elements[i],
+                       collection.remove(elements[i]));

            // if the elements aren't distinguishable, we can just remove a
            // matching element from the confirmed collection and verify
@@ -903,7 +927,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
                verifyAll();
            }

-            assertEquals(size - 1, collection.size(), "Collection should shrink after remove");
+            assertEquals("Collection should shrink after remove",
+                         size - 1, collection.size());
        }
    }

@@ -916,28 +941,28 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        if (!isRemoveSupported()) return;

        resetEmpty();
-        assertTrue(!collection.removeAll(Collections.EMPTY_SET),
-                "Emtpy collection removeAll should return false for " +
-                        "empty input");
+        assertTrue("Emtpy collection removeAll should return false for " +
+                   "empty input",
+                   !collection.removeAll(Collections.EMPTY_SET));
        verifyAll();

-        assertTrue(!collection.removeAll(new ArrayList(collection)),
-                "Emtpy collection removeAll should return false for " +
-                        "nonempty input");
+        assertTrue("Emtpy collection removeAll should return false for " +
+                   "nonempty input",
+                   !collection.removeAll(new ArrayList(collection)));
        verifyAll();

        resetFull();
-        assertTrue(!collection.removeAll(Collections.EMPTY_SET),
-                "Full collection removeAll should return false for " +
-                        "empty input");
+        assertTrue("Full collection removeAll should return false for " +
+                   "empty input",
+                   !collection.removeAll(Collections.EMPTY_SET));
        verifyAll();

-        assertTrue(!collection.removeAll(Arrays.asList(getOtherElements())),
-                "Full collection removeAll should return false for other elements");
+        assertTrue("Full collection removeAll should return false for other elements",
+                   !collection.removeAll(Arrays.asList(getOtherElements())));
        verifyAll();

-        assertTrue(collection.removeAll(new HashSet(collection)),
-                "Full collection removeAll should return true for full elements");
+        assertTrue("Full collection removeAll should return true for full elements",
+                    collection.removeAll(new HashSet(collection)));
        confirmed.removeAll(new HashSet(confirmed));
        verifyAll();

@@ -947,14 +972,17 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        int max = (getFullElements().length == 1 ? 1 :
                    (getFullElements().length <= 5 ? getFullElements().length - 1 : 5));
        Collection all = Arrays.asList(getFullElements()).subList(min, max);
-        assertTrue(collection.removeAll(all), "Full collection removeAll should work");
+        assertTrue("Full collection removeAll should work",
+                   collection.removeAll(all));
        confirmed.removeAll(all);
        verifyAll();

-        assertTrue(collection.size() < size, "Collection should shrink after removeAll");
+        assertTrue("Collection should shrink after removeAll",
+                   collection.size() < size);
        Iterator iter = all.iterator();
        while (iter.hasNext()) {
-            assertTrue(!collection.contains(iter.next()), "Collection shouldn't contain removed element");
+            assertTrue("Collection shouldn't contain removed element",
+                       !collection.contains(iter.next()));
        }
    }

@@ -970,51 +998,59 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        List elements = Arrays.asList(getFullElements());
        List other = Arrays.asList(getOtherElements());

-        assertTrue(!collection.retainAll(Collections.EMPTY_SET), "Empty retainAll() should return false");
+        assertTrue("Empty retainAll() should return false",
+                   !collection.retainAll(Collections.EMPTY_SET));
        verifyAll();

-        assertTrue(!collection.retainAll(elements), "Empty retainAll() should return false");
+        assertTrue("Empty retainAll() should return false",
+                   !collection.retainAll(elements));
        verifyAll();

        resetFull();
-        assertTrue(collection.retainAll(Collections.EMPTY_SET), "Collection should change from retainAll empty");
+        assertTrue("Collection should change from retainAll empty",
+                   collection.retainAll(Collections.EMPTY_SET));
        confirmed.retainAll(Collections.EMPTY_SET);
        verifyAll();

        resetFull();
-        assertTrue(collection.retainAll(other), "Collection changed from retainAll other");
+        assertTrue("Collection changed from retainAll other",
+                   collection.retainAll(other));
        confirmed.retainAll(other);
        verifyAll();

        resetFull();
        int size = collection.size();
-        assertTrue(!collection.retainAll(elements), "Collection shouldn't change from retainAll elements");
+        assertTrue("Collection shouldn't change from retainAll elements",
+                   !collection.retainAll(elements));
        verifyAll();
-        assertEquals(size, collection.size(), "Collection size shouldn't change");
+        assertEquals("Collection size shouldn't change", size,
+                     collection.size());

        if (getFullElements().length > 1) {
            resetFull();
            size = collection.size();
            int min = (getFullElements().length < 2 ? 0 : 2);
            int max = (getFullElements().length <= 5 ? getFullElements().length - 1 : 5);
-            assertTrue(collection.retainAll(elements.subList(min, max)), "Collection should changed by partial retainAll");
+            assertTrue("Collection should changed by partial retainAll",
+                       collection.retainAll(elements.subList(min, max)));
            confirmed.retainAll(elements.subList(min, max));
            verifyAll();

            Iterator iter = collection.iterator();
            while (iter.hasNext()) {
-                assertTrue(elements.subList(min, max).contains(iter.next()), "Collection only contains retained element");
+                assertTrue("Collection only contains retained element",
+                           elements.subList(min, max).contains(iter.next()));
            }
        }

        resetFull();
        HashSet set = new HashSet(elements);
        size = collection.size();
-        assertTrue(!collection.retainAll(set),
-                "Collection shouldn't change from retainAll without duplicate elements");
+        assertTrue("Collection shouldn't change from retainAll without " +
+                   "duplicate elements", !collection.retainAll(set));
        verifyAll();
-        assertEquals( size, collection.size(),
-                "Collection size didn't change from nonduplicate retainAll");
+        assertEquals("Collection size didn't change from nonduplicate " +
+                     "retainAll", size, collection.size());
    }


@@ -1024,10 +1060,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    @Test
    public void testCollectionSize() {
        resetEmpty();
-        assertEquals(0, collection.size(), "Size of new Collection is 0.");
+        assertEquals("Size of new Collection is 0.", 0, collection.size());

        resetFull();
-        assertTrue(collection.size() > 0, "Size of full collection should be greater than zero");
+        assertTrue("Size of full collection should be greater than zero",
+                   collection.size() > 0);
    }


@@ -1036,18 +1073,22 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
     */
    public void testCollectionToArray() {
        resetEmpty();
-        assertEquals(0, collection.toArray().length, "Empty Collection should return empty array for toArray");
+        assertEquals("Empty Collection should return empty array for toArray",
+                     0, collection.toArray().length);

        resetFull();
        Object[] array = collection.toArray();
-        assertEquals(array.length, collection.size(), "Full collection toArray should be same size as collection");
+        assertEquals("Full collection toArray should be same size as " +
+                     "collection", array.length, collection.size());
        Object[] confirmedArray = confirmed.toArray();
-        assertEquals(confirmedArray.length, array.length,
-                "length of array from confirmed collection should match the length of the collection's array");
+        assertEquals("length of array from confirmed collection should " +
+                     "match the length of the collection's array",
+                     confirmedArray.length, array.length);
        boolean[] matched = new boolean[array.length];

        for (int i = 0; i < array.length; i++) {
-            assertTrue(collection.contains(array[i]), "Collection should contain element in toArray");
+            assertTrue("Collection should contain element in toArray",
+                       collection.contains(array[i]));

            boolean match = false;
            // find a match in the confirmed array
@@ -1067,7 +1108,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
            }
        }
        for(int i = 0; i < matched.length; i++) {
-            assertEquals(true, matched[i], "Collection should return all its elements in toArray");
+            assertEquals("Collection should return all its elements in " +
+                         "toArray", true, matched[i]);
        }
    }

@@ -1081,8 +1123,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        resetEmpty();
        Object[] a = new Object[] { new Object(), null, null };
        Object[] array = collection.toArray(a);
-        assertArrayEquals(array, a, "Given array shouldn't shrink");
-        assertNull(a[0], "Last element should be set to null");
+        assertArrayEquals("Given array shouldn't shrink", array, a);
+        assertNull("Last element should be set to null", a[0]);
        verifyAll();

        resetFull();
@@ -1104,7 +1146,8 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {

        array = collection.toArray(new Object[0]);
        a = collection.toArray();
-        assertEquals(Arrays.asList(array), Arrays.asList(a), "toArrays should be equal");
+        assertEquals("toArrays should be equal",
+                     Arrays.asList(array), Arrays.asList(a));

        // Figure out if they're all the same class
        // TODO: It'd be nicer to detect a common superclass
@@ -1120,10 +1163,11 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
        }
        a = (Object[])Array.newInstance(cl, 0);
        array = collection.toArray(a);
-        assertEquals(a.getClass(), array.getClass(), "toArray(Object[]) should return correct array type");
-        assertEquals(Arrays.asList(array),
-                     Arrays.asList(collection.toArray()),
-                "type-specific toArrays should be equal");
+        assertEquals("toArray(Object[]) should return correct array type",
+                     a.getClass(), array.getClass());
+        assertEquals("type-specific toArrays should be equal",
+                     Arrays.asList(array),
+                     Arrays.asList(collection.toArray()));
        verifyAll();
    }

@@ -1134,10 +1178,12 @@ public abstract class CollectionAbstractTest extends ObjectAbstractTest {
    @Test
    public void testCollectionToString() {
        resetEmpty();
-        assertTrue(collection.toString() != null, "toString shouldn't return null");
+        assertTrue("toString shouldn't return null",
+                   collection.toString() != null);

        resetFull();
-        assertTrue(collection.toString() != null, "toString shouldn't return null");
+        assertTrue("toString shouldn't return null",
+                   collection.toString() != null);
    }


@@ -30,11 +30,13 @@

 package com.twelvemonkeys.util;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import java.util.*;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
+
 /**
 * CollectionUtilTest
 *
@@ -59,60 +61,44 @@ public class CollectionUtilTest {
        assertArrayEquals(new Object[] {"bar", "baz", 3}, merged);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectBadOffset() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 4, 2, integerObjects, 2, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 4, 2, integerObjects, 2, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectBadSecondOffset() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 4, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 4, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectBadLength() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, 4, integerObjects, 2, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, 4, integerObjects, 2, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectBadSecondLength() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, 2);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, 2);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectNegativeOffset() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, -1, 2, integerObjects, 2, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, -1, 2, integerObjects, 2, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectNegativeSecondOffset() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, -1, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, -1, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectNegativeLength() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, -1, integerObjects, 2, 1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, -1, integerObjects, 2, 1);
    }

-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
    public void testMergeArraysObjectNegativeSecondLength() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, -1);
-        });
+        CollectionUtil.mergeArrays(stringObjects, 1, 2, integerObjects, 2, -1);
    }

    @Test
@@ -123,24 +109,20 @@ public class CollectionUtilTest {
        assertArrayEquals(new Object[] {"foo", "bar", "baz", 1, 2, 3}, merged);
    }

-    @Test
+    @Test(expected = ArrayStoreException.class)
    public void testMergeArraysObjectIllegalType() {
        String[] strings = {"foo", "bar", "baz"};
        Integer[] integers = {1, 2, 3}; // Integer not assignable to String

-        assertThrows(ArrayStoreException.class, () -> {
-            CollectionUtil.mergeArrays(strings, integers);
-        });
+        CollectionUtil.mergeArrays(strings, integers);
    }

-    @Test
+    @Test(expected = ArrayStoreException.class)
    public void testMergeArraysNativeIllegalType() {
        char[] chars = {'a', 'b', 'c'};
        int[] integers = {1, 2, 3}; // Integer not assignable to String

-        assertThrows(ArrayStoreException.class, () -> {
-            CollectionUtil.mergeArrays(chars, integers);
-        });
+        CollectionUtil.mergeArrays(chars, integers);

    }

@@ -165,11 +147,9 @@ public class CollectionUtilTest {
        assertArrayEquals(new int[] {2, 3, 4}, numbers);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testEnumIteratorNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.iterator((Enumeration<Object>) null);
-        });
+        CollectionUtil.iterator((Enumeration<Object>) null);
    }
    
    @Test
@@ -203,11 +183,9 @@ public class CollectionUtilTest {
        }
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testArrayIteratorNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.iterator((Object[]) null);
-        });
+        CollectionUtil.iterator((Object[]) null);
    }

    @Test
@@ -284,7 +262,7 @@ public class CollectionUtilTest {

        int count = 0;
        for (Object element : elements) {
-            assertTrue(iterator.hasNext(), "No next element for element '" + element + "' at index: " + count);
+            assertTrue("No next element for element '" + element + "' at index: " + count, iterator.hasNext());
            assertEquals(count > 0, iterator.hasPrevious());
            assertEquals(count, iterator.nextIndex());
            assertEquals(count - 1, iterator.previousIndex());
@@ -340,7 +318,7 @@ public class CollectionUtilTest {
        assertEquals(elements.length, iterator.nextIndex());

        for (int i = count; i > 0; i--) {
-            assertTrue(iterator.hasPrevious(), "No previous element for element '" + elements[i - 1] + "' at index: " + (i - 1));
+            assertTrue("No previous element for element '" + elements[i - 1] + "' at index: " + (i - 1), iterator.hasPrevious());
            assertEquals(i < elements.length, iterator.hasNext());
            assertEquals(i - 1, iterator.previousIndex());
            assertEquals(i, iterator.nextIndex());
@@ -361,24 +339,18 @@ public class CollectionUtilTest {
        }
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testArrayIteratorRangeNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.iterator(null, 0, 0);
-        });
+        CollectionUtil.iterator(null, 0, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testArrayIteratorRangeBadStart() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.iterator(stringObjects, stringObjects.length + 1, 2);
-        });
+        CollectionUtil.iterator(stringObjects, stringObjects.length + 1, 2);
    }
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testArrayIteratorRangeBadLength() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.iterator(stringObjects, 1, stringObjects.length);
-        });
+        CollectionUtil.iterator(stringObjects, 1, stringObjects.length);
    }

    @Test
@@ -407,11 +379,9 @@ public class CollectionUtilTest {
        }
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReverseOrderNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            CollectionUtil.reverseOrder(null);
-        });
+        CollectionUtil.reverseOrder(null);
    }

    @Test
@@ -461,7 +431,7 @@ public class CollectionUtilTest {
        }
    }

-    @Disabled("For development only")
+    @Ignore("For development only")
    @Test
    @SuppressWarnings({"UnusedDeclaration"})
    public void testGenerify() {
@@ -45,10 +45,11 @@

 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.util.*;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertTrue;

 /**
 * Tests LRUMap.
@@ -80,8 +81,8 @@ public class LRUMapTest extends LinkedMapTest {
        map2.put(4,"foo"); // removes 1 since max size exceeded
        map2.removeLRU();  // should be Integer(2)

-        assertTrue(map2.get(new Integer(3)).equals("foo"), "Second to last value should exist");
-        assertTrue(map2.get(new Integer(1)) == null, "First value inserted should not exist");
+        assertTrue("Second to last value should exist",map2.get(new Integer(3)).equals("foo"));
+        assertTrue("First value inserted should not exist", map2.get(new Integer(1)) == null);
    }

    @Test
@@ -92,8 +93,8 @@ public class LRUMapTest extends LinkedMapTest {
        map2.put(3,"foo");
        map2.put(4,"bar");

-        assertTrue(map2.get(new Integer(4)).equals("bar"), "last value should exist");
-        assertTrue(map2.get(new Integer(1)) == null, "LRU should not exist");
+        assertTrue("last value should exist",map2.get(new Integer(4)).equals("bar"));
+        assertTrue("LRU should not exist", map2.get(new Integer(1)) == null);
    }

    /**
@@ -112,8 +113,10 @@ public class LRUMapTest extends LinkedMapTest {

        map2.putAll(hashMap);

-        assertTrue(map2.size() == 3, "max size is 3, but actual size is " + map2.size());
-        assertTrue(map2.containsKey(new Integer(4)), "map should contain the Integer(4) object");
+        assertTrue("max size is 3, but actual size is " + map2.size(),
+                   map2.size() == 3);
+        assertTrue("map should contain the Integer(4) object",
+                   map2.containsKey(new Integer(4)));
    }

    /**
@@ -131,7 +134,8 @@ public class LRUMapTest extends LinkedMapTest {
        map.put("6","6");
        map.setMaxSize(3);

-        assertTrue(map.size() == 3, "map should have size = 3, but actually = " + map.size());
+        assertTrue("map should have size = 3, but actually = " + map.size(),
+                   map.size() == 3);
    }

    @Test
@@ -156,9 +160,9 @@ public class LRUMapTest extends LinkedMapTest {
            keys[i] = keyIterator.next();
        }

-        assertTrue(keys[0].equals("3"), "first evicted should be 3, was " + keys[0]);
-        assertTrue(keys[1].equals("1"), "second evicted should be 1, was " + keys[1]);
-        assertTrue(keys[2].equals("4"), "third evicted should be 4, was " + keys[2]);
+        assertTrue("first evicted should be 3, was " + keys[0], keys[0].equals("3"));
+        assertTrue("second evicted should be 1, was " + keys[1], keys[1].equals("1"));
+        assertTrue("third evicted should be 4, was " + keys[2], keys[2].equals("4"));

    }

@@ -188,12 +192,13 @@ public class LRUMapTest extends LinkedMapTest {
        // 4 2
        counter.remove("5");

-        assertTrue(counter.size() == 2, "size should be 2, but was " + counter.size());
-        assertTrue(counter.removedCount == 3, "removedCount should be 3 but was " + counter.removedCount);
+        assertTrue("size should be 2, but was " + counter.size(), counter.size() == 2);
+        assertTrue("removedCount should be 3 but was " + counter.removedCount,
+                   counter.removedCount == 3);

-        assertTrue(counter.list.get(0).equals("2"), "first removed was '2'");
-        assertTrue(counter.list.get(1).equals("3"), "second removed was '3'");
-        assertTrue(counter.list.get(2).equals("1"), "third removed was '1'");
+        assertTrue("first removed was '2'",counter.list.get(0).equals("2"));
+        assertTrue("second removed was '3'",counter.list.get(1).equals("3"));
+        assertTrue("third removed was '1'",counter.list.get(2).equals("1"));

        //assertTrue("oldest key is '4'",counter.get(0).equals("4"));
        //assertTrue("newest key is '2'",counter.get(1).equals("2"));
@@ -45,11 +45,15 @@

 package com.twelvemonkeys.util;

+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
 import java.util.Iterator;
 import java.util.Map;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;

 /**
 * Unit tests
@@ -70,7 +74,7 @@ public class LinkedMapTest extends MapAbstractTest {
     */
    protected LinkedMap labRat;

-    @BeforeEach
+    @Before
    public void setUp() throws Exception {
        // use makeMap and cast the result to a SeqHashMap
        // so that subclasses of SeqHashMap can share these tests
@@ -99,21 +103,27 @@ public class LinkedMapTest extends MapAbstractTest {
        }

        // Test size().
-        assertEquals(expectedSize, labRat.size(), "size() does not match expected size");
+        assertEquals("size() does not match expected size",
+                     expectedSize, labRat.size());

        // Test clone(), iterator(), and get(Object).
        LinkedMap clone = (LinkedMap) labRat.clone();
-        assertEquals(labRat.size(), clone.size(), "Size of clone does not match original");
+        assertEquals("Size of clone does not match original",
+                     labRat.size(), clone.size());
        Iterator origEntries = labRat.entrySet().iterator();
        Iterator copiedEntries = clone.entrySet().iterator();
        while (origEntries.hasNext()) {
            Map.Entry origEntry = (Map.Entry)origEntries.next();
            Map.Entry copiedEntry = (Map.Entry)copiedEntries.next();
-            assertEquals(origEntry.getKey(), copiedEntry.getKey(), "Cloned key does not match original");
-            assertEquals(origEntry.getValue(), copiedEntry.getValue(), "Cloned value does not match original");
-            assertEquals(origEntry, copiedEntry, "Cloned entry does not match original");
+            assertEquals("Cloned key does not match original",
+                         origEntry.getKey(), copiedEntry.getKey());
+            assertEquals("Cloned value does not match original",
+                         origEntry.getValue(), copiedEntry.getValue());
+            assertEquals("Cloned entry does not match original",
+                         origEntry, copiedEntry);
        }
-        assertTrue(!copiedEntries.hasNext(), "iterator() returned different number of elements than keys()");
+        assertTrue("iterator() returned different number of elements than keys()",
+               !copiedEntries.hasNext());

        // Test sequence()
        /*
@@ -197,7 +207,7 @@ public class LinkedMapTest extends MapAbstractTest {
    }
    */

-    @AfterEach
+    @After
    public void tearDown() throws Exception {
        labRat = null;
    }
@@ -45,10 +45,12 @@

 package com.twelvemonkeys.util;

+import org.junit.After;
+import org.junit.Test;
+
 import java.util.*;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * Abstract test class for {@link java.util.Map} methods and contracts.
@@ -388,19 +390,19 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                m.put(keys[i], values[i]);
            }
            catch (NullPointerException exception) {
-                assertTrue(keys[i] == null || values[i] == null,
-                        "NullPointerException only allowed to be thrown if either the key or value is null.");
+                assertTrue("NullPointerException only allowed to be thrown if either the key or value is null.",
+                        keys[i] == null || values[i] == null);

-                assertTrue(keys[i] == null || !isAllowNullKey(),
-                        "NullPointerException on null key, but isAllowNullKey is not overridden to return false.");
+                assertTrue("NullPointerException on null key, but isAllowNullKey is not overridden to return false.",
+                        keys[i] == null || !isAllowNullKey());

-                assertTrue(values[i] == null || !isAllowNullValue(),
-                        "NullPointerException on null value, but isAllowNullValue is not overridden to return false.");
+                assertTrue("NullPointerException on null value, but isAllowNullValue is not overridden to return false.",
+                        values[i] == null || !isAllowNullValue());

-                fail("Unknown reason for NullPointer.");
+                assertTrue("Unknown reason for NullPointer.", false);
            }
        }
-        assertEquals(keys.length, m.size(), "size must reflect number of mappings added.");
+        assertEquals("size must reflect number of mappings added.", keys.length, m.size());
    }

    //-----------------------------------------------------------------------
@@ -479,26 +481,27 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        Object[] values = getSampleValues();
        Object[] newValues = getNewSampleValues();

-        assertTrue(keys != null, "failure in test: Must have keys returned from getSampleKeys.");
-        assertTrue(values != null, "failure in test: Must have values returned from getSampleValues.");
+        assertTrue("failure in test: Must have keys returned from getSampleKeys.", keys != null);
+        assertTrue("failure in test: Must have values returned from getSampleValues.", values != null);

        // verify keys and values have equivalent lengths (in case getSampleX are
        // overridden)
-        assertEquals(keys.length, values.length, "failure in test: not the same number of sample keys and values.");
-        assertEquals(values.length, newValues.length, "failure in test: not the same number of values and new values.");
+        assertEquals("failure in test: not the same number of sample keys and values.", keys.length, values.length);
+        assertEquals("failure in test: not the same number of values and new values.", values.length, newValues.length);

        // verify there aren't duplicate keys, and check values
        for (int i = 0; i < keys.length - 1; i++) {
            for (int j = i + 1; j < keys.length; j++) {
-                assertTrue((keys[i] != null || keys[j] != null), "failure in test: duplicate null keys.");
-                assertTrue((keys[i] == null || keys[j] == null || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))),
-                        "failure in test: duplicate non-null key.");
+                assertTrue("failure in test: duplicate null keys.", (keys[i] != null || keys[j] != null));
+                assertTrue("failure in test: duplicate non-null key.",
+                        (keys[i] == null || keys[j] == null || (!keys[i].equals(keys[j]) && !keys[j].equals(keys[i]))));
            }

-            assertTrue(keys[i] != null || isAllowNullKey(),"failure in test: found null key, but isNullKeySupported is false.");
-            assertTrue(values[i] != null || isAllowNullValue(),"failure in test: found null value, but isNullValueSupported is false.");
-            assertTrue(newValues[i] != null || isAllowNullValue(), "failure in test: found null new value, but isNullValueSupported is false.");
-            assertTrue(values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])), "failure in test: values should not be the same as new value");
+            assertTrue("failure in test: found null key, but isNullKeySupported is false.", keys[i] != null || isAllowNullKey());
+            assertTrue("failure in test: found null value, but isNullValueSupported is false.", values[i] != null || isAllowNullValue());
+            assertTrue("failure in test: found null new value, but isNullValueSupported is false.", newValues[i] != null || isAllowNullValue());
+            assertTrue("failure in test: values should not be the same as new value",
+                    values[i] != newValues[i] && (values[i] == null || !values[i].equals(newValues[i])));
        }
    }

@@ -514,18 +517,18 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMakeMap() {
        Map em = makeEmptyMap();
-        assertTrue(em != null, "failure in test: makeEmptyMap must return a non-null map.");
+        assertTrue("failure in test: makeEmptyMap must return a non-null map.", em != null);

        Map em2 = makeEmptyMap();
-        assertTrue(em2 != null, "failure in test: makeEmptyMap must return a non-null map.");
-        assertTrue(em != em2, "failure in test: makeEmptyMap must return a new map with each invocation.");
+        assertTrue("failure in test: makeEmptyMap must return a non-null map.", em2 != null);
+        assertTrue("failure in test: makeEmptyMap must return a new map with each invocation.", em != em2);

        Map fm = makeFullMap();
-        assertTrue(fm != null, "failure in test: makeFullMap must return a non-null map.");
+        assertTrue("failure in test: makeFullMap must return a non-null map.", fm != null);

        Map fm2 = makeFullMap();
-        assertTrue(fm2 != null, "failure in test: makeFullMap must return a non-null map.");
-        assertTrue(fm != fm2, "failure in test: makeFullMap must return a new map with each invocation.");
+        assertTrue("failure in test: makeFullMap must return a non-null map.", fm2 != null);
+        assertTrue("failure in test: makeFullMap must return a new map with each invocation.", fm != fm2);
    }

    /**
@@ -534,11 +537,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMapIsEmpty() {
        resetEmpty();
-        assertEquals(true, map.isEmpty(), "Map.isEmpty() should return true with an empty map");
+        assertEquals("Map.isEmpty() should return true with an empty map", true, map.isEmpty());
        verifyAll();

        resetFull();
-        assertEquals(false, map.isEmpty(), "Map.isEmpty() should return false with a non-empty map");
+        assertEquals("Map.isEmpty() should return false with a non-empty map", false, map.isEmpty());
        verifyAll();
    }

@@ -548,11 +551,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMapSize() {
        resetEmpty();
-        assertEquals(0, map.size(), "Map.size() should be 0 with an empty map");
+        assertEquals("Map.size() should be 0 with an empty map", 0, map.size());
        verifyAll();

        resetFull();
-        assertEquals(getSampleKeys().length, map.size(), "Map.size() should equal the number of entries in the map");
+        assertEquals("Map.size() should equal the number of entries in the map", getSampleKeys().length, map.size());
        verifyAll();
    }

@@ -599,13 +602,13 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {

        resetEmpty();
        for (Object key : keys) {
-            assertTrue(!map.containsKey(key), "Map must not contain key when map is empty");
+            assertTrue("Map must not contain key when map is empty", !map.containsKey(key));
        }
        verifyAll();

        resetFull();
        for (Object key : keys) {
-            assertTrue(map.containsKey(key), "Map must contain key for a mapping in the map. Missing: " + key);
+            assertTrue("Map must contain key for a mapping in the map. Missing: " + key, map.containsKey(key));
        }
        verifyAll();
    }
@@ -621,13 +624,13 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {

        resetEmpty();
        for (Object value : values) {
-            assertTrue(!map.containsValue(value), "Empty map must not contain value");
+            assertTrue("Empty map must not contain value", !map.containsValue(value));
        }
        verifyAll();

        resetFull();
        for (Object value : values) {
-            assertTrue(map.containsValue(value), "Map must contain value for a mapping in the map.");
+            assertTrue("Map must contain value for a mapping in the map.", map.containsValue(value));
        }
        verifyAll();
    }
@@ -638,11 +641,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMapEquals() {
        resetEmpty();
-        assertTrue(map.equals(confirmed), "Empty maps unequal.");
+        assertTrue("Empty maps unequal.", map.equals(confirmed));
        verifyAll();

        resetFull();
-        assertTrue(map.equals(confirmed), "Full maps unequal.");
+        assertTrue("Full maps unequal.", map.equals(confirmed));
        verifyAll();

        resetFull();
@@ -651,11 +654,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        Iterator iter = confirmed.keySet().iterator();
        iter.next();
        iter.remove();
-        assertTrue(!map.equals(confirmed), "Different maps equal.");
+        assertTrue("Different maps equal.", !map.equals(confirmed));

        resetFull();
-        assertTrue(!map.equals(null), "equals(null) returned true.");
-        assertTrue(!map.equals(new Object()), "equals(new Object()) returned true.");
+        assertTrue("equals(null) returned true.", !map.equals(null));
+        assertTrue("equals(new Object()) returned true.", !map.equals(new Object()));
        verifyAll();
    }

@@ -670,14 +673,14 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        Object[] values = getSampleValues();

        for (Object key : keys) {
-            assertTrue(map.get(key) == null, "Empty map.get() should return null.");
+            assertTrue("Empty map.get() should return null.", map.get(key) == null);
        }

        verifyAll();

        resetFull();
        for (int i = 0; i < keys.length; i++) {
-            assertEquals(values[i], map.get(keys[i]), "Full map.get() should return value from mapping.");
+            assertEquals("Full map.get() should return value from mapping.", values[i], map.get(keys[i]));
        }
    }

@@ -687,10 +690,10 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMapHashCode() {
        resetEmpty();
-        assertTrue(map.hashCode() == confirmed.hashCode(), "Empty maps have different hashCodes.");
+        assertTrue("Empty maps have different hashCodes.", map.hashCode() == confirmed.hashCode());

        resetFull();
-        assertTrue(map.hashCode() == confirmed.hashCode(), "Equal maps have different hashCodes.");
+        assertTrue("Equal maps have different hashCodes.", map.hashCode() == confirmed.hashCode());
    }

    /**
@@ -705,11 +708,11 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    @Test
    public void testMapToString() {
        resetEmpty();
-        assertTrue(map.toString() != null, "Empty map toString() should not return null");
+        assertTrue("Empty map toString() should not return null", map.toString() != null);
        verifyAll();

        resetFull();
-        assertTrue(map.toString() != null, "Empty map toString() should not return null");
+        assertTrue("Empty map toString() should not return null", map.toString() != null);
        verifyAll();
    }

@@ -773,23 +776,29 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                Object o = map.put(keys[i], values[i]);
                confirmed.put(keys[i], values[i]);
                verifyAll();
-                assertTrue(o == null, "First map.put should return null");
-                assertTrue(map.containsKey(keys[i]), "Map should contain key after put");
-                assertTrue(map.containsValue(values[i]), "Map should contain value after put");
+                assertTrue("First map.put should return null", o == null);
+                assertTrue("Map should contain key after put",
+                        map.containsKey(keys[i]));
+                assertTrue("Map should contain value after put",
+                        map.containsValue(values[i]));
            }
            if (isPutChangeSupported()) {
                for (int i = 0; i < keys.length; i++) {
                    Object o = map.put(keys[i], newValues[i]);
                    confirmed.put(keys[i], newValues[i]);
                    verifyAll();
-                    assertEquals(values[i], o, "Map.put should return previous value when changed");
-                    assertTrue(map.containsKey(keys[i]), "Map should still contain key after put when changed");
-                    assertTrue(map.containsValue(newValues[i]), "Map should contain new value after put when changed");
+                    assertEquals("Map.put should return previous value when changed",
+                            values[i], o);
+                    assertTrue("Map should still contain key after put when changed",
+                            map.containsKey(keys[i]));
+                    assertTrue("Map should contain new value after put when changed",
+                            map.containsValue(newValues[i]));

                    // if duplicates are allowed, we're not guaranteed that the value
                    // no longer exists, so don't try checking that.
                    if (!isAllowDuplicateValues()) {
-                        assertTrue(!map.containsValue(values[i]), "Map should not contain old value after put when changed");
+                        assertTrue("Map should not contain old value after put when changed",
+                                !map.containsValue(values[i]));
                    }
                }
            }
@@ -823,14 +832,18 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                Object o = map.put(key, newValues[i]);
                Object value = confirmed.put(key, newValues[i]);
                verifyAll();
-                assertEquals(value, o, "Map.put should return previous value when changed");
-                assertTrue(map.containsKey(key), "Map should still contain key after put when changed");
-                assertTrue(map.containsValue(newValues[i]), "Map should contain new value after put when changed");
+                assertEquals("Map.put should return previous value when changed",
+                        value, o);
+                assertTrue("Map should still contain key after put when changed",
+                        map.containsKey(key));
+                assertTrue("Map should contain new value after put when changed",
+                        map.containsValue(newValues[i]));

                // if duplicates are allowed, we're not guaranteed that the value
                // no longer exists, so don't try checking that.
                if (!isAllowDuplicateValues()) {
-                    assertTrue(!map.containsValue(values[i]), "Map should not contain old value after put when changed");
+                    assertTrue("Map should not contain old value after put when changed",
+                            !map.containsValue(values[i]));
                }
            }
        }
@@ -957,7 +970,7 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        Object[] values = getSampleValues();
        for (int i = 0; i < keys.length; i++) {
            Object o = map.remove(keys[i]);
-            assertTrue(o == null, "First map.remove should return null");
+            assertTrue("First map.remove should return null", o == null);
        }
        verifyAll();

@@ -968,7 +981,8 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
            confirmed.remove(keys[i]);
            verifyAll();

-            assertEquals(values[i], o, "map.remove with valid key should return value");
+            assertEquals("map.remove with valid key should return value",
+                    values[i], o);
        }

        Object[] other = getOtherKeys();
@@ -977,8 +991,10 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        int size = map.size();
        for (int i = 0; i < other.length; i++) {
            Object o = map.remove(other[i]);
-            assertEquals(o, null, "map.remove for nonexistent key should return null");
-            assertEquals(size, map.size(), "map.remove for nonexistent key should not shrink map");
+            assertEquals("map.remove for nonexistent key should return null",
+                    o, null);
+            assertEquals("map.remove for nonexistent key should not " +
+                    "shrink map", size, map.size());
        }
        verifyAll();
    }
@@ -1188,9 +1204,10 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                    }
                    j++;
                }
-                assertTrue(j < 10000, "values().remove(obj) is broken");
-                assertTrue(!map.containsValue(sampleValues[i]),
-                        "Value should have been removed from the underlying map.");
+                assertTrue("values().remove(obj) is broken", j < 10000);
+                assertTrue(
+                        "Value should have been removed from the underlying map.",
+                        !map.containsValue(sampleValues[i]));
            }
        }
    }
@@ -1213,8 +1230,9 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                // if key.remove is unsupported, just skip this test
                return;
            }
-            assertTrue(!map.containsKey(sampleKeys[i]),
-                    "Key should have been removed from the underlying map.");
+            assertTrue(
+                    "Key should have been removed from the underlying map.",
+                    !map.containsKey(sampleKeys[i]));
        }
    }

@@ -1395,7 +1413,7 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
                    break;
                }
            }
-            assertNotNull(entry, "No matching entry in map for key '" + key + "'");
+            assertNotNull("No matching entry in map for key '" + key + "'", entry);
            return entry;
        }

@@ -1620,14 +1638,14 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    public void verifyMap() {
        int size = confirmed.size();
        boolean empty = confirmed.isEmpty();
-        assertEquals(size, map.size(), "Map should be same size as HashMap");
-        assertEquals(empty, map.isEmpty(), "Map should be empty if HashMap is");
-        assertEquals(confirmed.hashCode(), map.hashCode(), "hashCodes should be the same");
+        assertEquals("Map should be same size as HashMap", size, map.size());
+        assertEquals("Map should be empty if HashMap is", empty, map.isEmpty());
+        assertEquals("hashCodes should be the same", confirmed.hashCode(), map.hashCode());
        // this fails for LRUMap because confirmed.equals() somehow modifies
        // map, causing concurrent modification exceptions.
        //assertEquals("Map should still equal HashMap", confirmed, map);
        // this works though and performs the same verification:
-        assertTrue(map.equals(confirmed), "Map should still equal HashMap");
+        assertTrue("Map should still equal HashMap", map.equals(confirmed));
        // TODO: this should really be reexamined to figure out why LRU map
        // behaves like it does (the equals shouldn't modify since all accesses
        // by the confirmed collection should be through an iterator, thus not
@@ -1637,29 +1655,29 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
    public void verifyEntrySet() {
        int size = confirmed.size();
        boolean empty = confirmed.isEmpty();
-        assertEquals(size, entrySet.size(),
-                "entrySet should be same size as HashMap's\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
-        assertEquals(empty, entrySet.isEmpty(),
-                "entrySet should be empty if HashMap is\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
-        assertTrue(entrySet.containsAll(confirmed.entrySet()),
-                "entrySet should contain all HashMap's elements\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
-        assertEquals(confirmed.entrySet().hashCode(), entrySet.hashCode(),
-                "entrySet hashCodes should be the same\nTest: " + entrySet + "\nReal: " + confirmed.entrySet());
-        assertEquals(confirmed.entrySet(), entrySet,"Map's entry set should still equal HashMap's");
+        assertEquals("entrySet should be same size as HashMap's\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
+                size, entrySet.size());
+        assertEquals("entrySet should be empty if HashMap is\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
+                empty, entrySet.isEmpty());
+        assertTrue("entrySet should contain all HashMap's elements\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
+                entrySet.containsAll(confirmed.entrySet()));
+        assertEquals("entrySet hashCodes should be the same\nTest: " + entrySet + "\nReal: " + confirmed.entrySet(),
+                confirmed.entrySet().hashCode(), entrySet.hashCode());
+        assertEquals("Map's entry set should still equal HashMap's", confirmed.entrySet(), entrySet);
    }

    public void verifyKeySet() {
        int size = confirmed.size();
        boolean empty = confirmed.isEmpty();
-        assertEquals(size, keySet.size(),
-                "keySet should be same size as HashMap's\nTest: " + keySet + "\nReal: " + confirmed.keySet());
-        assertEquals(empty, keySet.isEmpty(),
-                "keySet should be empty if HashMap is\nTest: " + keySet + "\nReal: " + confirmed.keySet());
-        assertTrue(keySet.containsAll(confirmed.keySet()),
-                "keySet should contain all HashMap's elements\nTest: " + keySet + "\nReal: " + confirmed.keySet());
-        assertEquals(confirmed.keySet().hashCode(), keySet.hashCode(),
-                "keySet hashCodes should be the same\nTest: " + keySet + "\nReal: " + confirmed.keySet());
-        assertEquals(confirmed.keySet(), keySet, "Map's key set should still equal HashMap's");
+        assertEquals("keySet should be same size as HashMap's\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
+                size, keySet.size());
+        assertEquals("keySet should be empty if HashMap is\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
+                empty, keySet.isEmpty());
+        assertTrue("keySet should contain all HashMap's elements\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
+                keySet.containsAll(confirmed.keySet()));
+        assertEquals("keySet hashCodes should be the same\nTest: " + keySet + "\nReal: " + confirmed.keySet(),
+                confirmed.keySet().hashCode(), keySet.hashCode());
+        assertEquals("Map's key set should still equal HashMap's", confirmed.keySet(), keySet);
    }

    public void verifyValues() {
@@ -1669,23 +1687,23 @@ public abstract class MapAbstractTest extends ObjectAbstractTest {
        int size = confirmed.size();
        boolean empty = confirmed.isEmpty();

-        assertEquals(size, values.size(), "values should be same size as HashMap's\nTest: " + test + "\nReal: " + known);
-        assertEquals(empty, values.isEmpty(), "values should be empty if HashMap is\nTest: " + test + "\nReal: " + known);
-        assertTrue(test.containsAll(known), "values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known);
-        assertTrue(known.containsAll(test), "values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known);
+        assertEquals("values should be same size as HashMap's\nTest: " + test + "\nReal: " + known, size, values.size());
+        assertEquals("values should be empty if HashMap is\nTest: " + test + "\nReal: " + known, empty, values.isEmpty());
+        assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, test.containsAll(known));
+        assertTrue("values should contain all HashMap's elements\nTest: " + test + "\nReal: " + known, known.containsAll(test));

        for (Object aKnown : known) {
            boolean removed = test.remove(aKnown);
-            assertTrue(removed, "Map's values should still equal HashMap's");
+            assertTrue("Map's values should still equal HashMap's", removed);
        }

-        assertTrue(test.isEmpty(), "Map's values should still equal HashMap's");
+        assertTrue("Map's values should still equal HashMap's", test.isEmpty());
    }

    /**
     * Erases any leftover instance variables by setting them to null.
     */
-    @AfterEach
+    @After
    public void tearDown() throws Exception {
        map = null;
        keySet = null;
@@ -30,11 +30,13 @@

 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.util.HashMap;
 import java.util.Map;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;

 /**
 * NOTE: This TestCase is written especially for NullMap, and is full of dirty
@@ -81,12 +83,12 @@ public class NullMapTest extends MapAbstractTest {
    @Override
    public void testMapIsEmpty() {
        resetEmpty();
-        assertEquals(true, map.isEmpty(),
-                "Map.isEmpty() should return true with an empty map");
+        assertEquals("Map.isEmpty() should return true with an empty map",
+                     true, map.isEmpty());
        verifyAll();
        resetFull();
-        assertEquals(true, map.isEmpty(),
-                "Map.isEmpty() should return true with a full map");
+        assertEquals("Map.isEmpty() should return true with a full map",
+                     true, map.isEmpty());
    }

    // Overriden, as this map is always empty
@@ -94,13 +96,13 @@ public class NullMapTest extends MapAbstractTest {
    @Override
    public void testMapSize() {
        resetEmpty();
-        assertEquals(0, map.size(),
-                "Map.size() should be 0 with an empty map");
+        assertEquals("Map.size() should be 0 with an empty map",
+                     0, map.size());
        verifyAll();

        resetFull();
-        assertEquals(0, map.size(),
-                "Map.size() should equal the number of entries in the map");
+        assertEquals("Map.size() should equal the number of entries " +
+                     "in the map", 0, map.size());
    }

    @Test
@@ -110,7 +112,7 @@ public class NullMapTest extends MapAbstractTest {

        resetEmpty();
        for (Object key : keys) {
-            assertTrue(!map.containsKey(key),"Map must not contain key when map is empty");
+            assertTrue("Map must not contain key when map is empty", !map.containsKey(key));
        }
        verifyAll();
    }
@@ -122,7 +124,7 @@ public class NullMapTest extends MapAbstractTest {

        resetEmpty();
        for (Object value : values) {
-            assertTrue(!map.containsValue(value), "Empty map must not contain value");
+            assertTrue("Empty map must not contain value", !map.containsValue(value));
        }
        verifyAll();
    }
@@ -131,7 +133,7 @@ public class NullMapTest extends MapAbstractTest {
    @Override
    public void testMapEquals() {
        resetEmpty();
-        assertTrue(map.equals(confirmed), "Empty maps unequal.");
+        assertTrue("Empty maps unequal.", map.equals(confirmed));
        verifyAll();
    }

@@ -139,7 +141,8 @@ public class NullMapTest extends MapAbstractTest {
    @Override
    public void testMapHashCode() {
        resetEmpty();
-        assertTrue(map.hashCode() == confirmed.hashCode(), "Empty maps have different hashCodes.");
+        assertTrue("Empty maps have different hashCodes.",
+                   map.hashCode() == confirmed.hashCode());
    }

    @Test
@@ -150,7 +153,7 @@ public class NullMapTest extends MapAbstractTest {
        Object[] keys = getSampleKeys();

        for (Object key : keys) {
-            assertTrue(map.get(key) == null, "Empty map.get() should return null.");
+            assertTrue("Empty map.get() should return null.", map.get(key) == null);
        }
        verifyAll();
    }
@@ -167,7 +170,7 @@ public class NullMapTest extends MapAbstractTest {
            Object o = map.put(keys[i], values[i]);
            //confirmed.put(keys[i], values[i]);
            verifyAll();
-            assertTrue(o == null, "First map.put should return null");
+            assertTrue("First map.put should return null", o == null);
        }
        for (int i = 0; i < keys.length; i++) {
            map.put(keys[i], newValues[i]);
@@ -180,8 +183,8 @@ public class NullMapTest extends MapAbstractTest {
    @Override
    public void testMapToString() {
        resetEmpty();
-        assertTrue(map.toString() != null,
-                "Empty map toString() should not return null");
+        assertTrue("Empty map toString() should not return null",
+                   map.toString() != null);
        verifyAll();
    }

@@ -199,7 +202,7 @@ public class NullMapTest extends MapAbstractTest {
        Object[] keys = getSampleKeys();
        for(int i = 0; i < keys.length; i++) {
            Object o = map.remove(keys[i]);
-            assertTrue(o == null, "First map.remove should return null");
+            assertTrue("First map.remove should return null", o == null);
        }
        verifyAll();
    }
@@ -44,10 +44,12 @@
 */
 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.io.*;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;

 /**
 * Abstract test class for {@link Object} methods and contracts.
@@ -117,7 +119,7 @@ public abstract class ObjectAbstractTest {
    @Test
    public void testObjectEqualsSelf() {
        Object obj = makeObject();
-        assertEquals(obj, obj, "A Object should equal itself");
+        assertEquals("A Object should equal itself", obj, obj);
    }

    @Test
@@ -129,24 +131,25 @@ public abstract class ObjectAbstractTest {
    @Test
    public void testObjectHashCodeEqualsSelfHashCode() {
        Object obj = makeObject();
-        assertEquals(obj.hashCode(), obj.hashCode(), "hashCode should be repeatable");
+        assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
    }

    @Test
    public void testObjectHashCodeEqualsContract() {
        Object obj1 = makeObject();
        if (obj1.equals(obj1)) {
-            assertEquals(obj1.hashCode(), obj1.hashCode(),
-                    "[1] When two objects are equal, their hashCodes should be also.");
+            assertEquals(
+                "[1] When two objects are equal, their hashCodes should be also.",
+                obj1.hashCode(), obj1.hashCode());
        }
        Object obj2 = makeObject();
        if (obj1.equals(obj2)) {
            assertEquals(
-                obj1.hashCode(), obj2.hashCode(),
-                    "[2] When two objects are equal, their hashCodes should be also.");
+                "[2] When two objects are equal, their hashCodes should be also.",
+                obj1.hashCode(), obj2.hashCode());
            assertTrue(
-                obj2.equals(obj1),
-                    "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true");
+                "When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
+                obj2.equals(obj1));
        }
    }

@@ -163,7 +166,7 @@ public abstract class ObjectAbstractTest {
            Object dest = in.readObject();
            in.close();
            if (isEqualsCheckable()) {
-                assertEquals(obj, dest, "obj != deserialize(serialize(obj))");
+                assertEquals("obj != deserialize(serialize(obj))", obj, dest);
            }
        }
    }
@@ -196,8 +199,8 @@ public abstract class ObjectAbstractTest {
            if (object instanceof Serializable) {
                String name = getCanonicalEmptyCollectionName(object);
                assertTrue(
-                    new File(name).exists(),
-                        "Canonical empty collection (" + name + ") is not in CVS");
+                    "Canonical empty collection (" + name + ") is not in CVS",
+                    new File(name).exists());
            }
        }
    }
@@ -213,8 +216,8 @@ public abstract class ObjectAbstractTest {
            if (object instanceof Serializable) {
                String name = getCanonicalFullCollectionName(object);
                assertTrue(
-                    new File(name).exists(),
-                        "Canonical full collection (" + name + ") is not in CVS");
+                    "Canonical full collection (" + name + ") is not in CVS",
+                    new File(name).exists());
            }
        }
    }
@@ -44,10 +44,12 @@
 */
 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.util.*;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;

 /**
 * Abstract test class for {@link Set} methods and contracts.
@@ -77,12 +79,14 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
    public void verifyAll() {
        super.verifyAll();

-        assertEquals(confirmed, collection, "Sets should be equal");
-        assertEquals(confirmed.hashCode(), collection.hashCode(), "Sets should have equal hashCodes");
+        assertEquals("Sets should be equal", confirmed, collection);
+        assertEquals("Sets should have equal hashCodes",
+                     confirmed.hashCode(), collection.hashCode());
        Collection set = makeConfirmedCollection();
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
-            assertTrue(set.add(iterator.next()), "Set.iterator should only return unique elements");
+            assertTrue("Set.iterator should only return unique elements",
+                       set.add(iterator.next()));
        }
    }

@@ -176,20 +180,23 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
    @Test
    public void testSetEquals() {
        resetEmpty();
-        assertEquals(getSet(), getConfirmedSet(), "Empty sets should be equal");
+        assertEquals("Empty sets should be equal",
+                     getSet(), getConfirmedSet());
        verifyAll();

        Collection set2 = makeConfirmedCollection();
        set2.add("foo");
-        assertTrue(!getSet().equals(set2), "Empty set shouldn't equal nonempty set");
+        assertTrue("Empty set shouldn't equal nonempty set",
+                   !getSet().equals(set2));

        resetFull();
-        assertEquals(getSet(), getConfirmedSet(), "Full sets should be equal");
+        assertEquals("Full sets should be equal", getSet(), getConfirmedSet());
        verifyAll();

        set2.clear();
        set2.addAll(Arrays.asList(getOtherElements()));
-        assertTrue(!getSet().equals(set2), "Sets with different contents shouldn't be equal");
+        assertTrue("Sets with different contents shouldn't be equal",
+                   !getSet().equals(set2));
    }

    /**
@@ -198,9 +205,11 @@ public abstract class SetAbstractTest extends CollectionAbstractTest {
    @Test
    public void testSetHashCode() {
        resetEmpty();
-        assertEquals(getSet().hashCode(), getConfirmedSet().hashCode(), "Empty sets have equal hashCodes");
+        assertEquals("Empty sets have equal hashCodes",
+                     getSet().hashCode(), getConfirmedSet().hashCode());

        resetFull();
-        assertEquals(getSet().hashCode(), getConfirmedSet().hashCode(), "Equal sets have equal hashCodes");
+        assertEquals("Equal sets have equal hashCodes",
+                     getSet().hashCode(), getConfirmedSet().hashCode());
    }
 }
@@ -30,10 +30,12 @@

 package com.twelvemonkeys.util;

+
+import org.junit.Test;
+
 import java.util.Iterator;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * StringTokenIteratorTestCase
@@ -54,88 +56,88 @@ public class StringTokenIteratorTest extends TokenIteratorAbstractTest {
    @Test
    public void testEmptyDelimiter() {
        Iterator iterator = createTokenIterator("", "");
-        assertFalse(iterator.hasNext(), "Empty string has elements");
+        assertFalse("Empty string has elements", iterator.hasNext());
    }

    @Test
    public void testSingleToken() {
        Iterator iterator = createTokenIterator("A");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleTokenEmptyDelimiter() {
        Iterator iterator = createTokenIterator("A", "");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleTokenSingleDelimiter() {
        Iterator iterator = createTokenIterator("A", ",");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleSeparatorDefaultDelimiter() {
        Iterator iterator = createTokenIterator("A B C D");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleSeparator() {
        Iterator iterator = createTokenIterator("A,B,C", ",");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testMultipleSeparatorDefaultDelimiter() {
        Iterator iterator = createTokenIterator("A B   C\nD\t\t \nE");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("E", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testMultipleSeparator() {
        Iterator iterator = createTokenIterator("A,B,;,C...D, ., ,E", " ,.;:");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("E", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }
 }
@@ -30,10 +30,12 @@

 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.util.*;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
+
 /**
 * TimeoutMapTest
 * <p/>
@@ -539,7 +541,7 @@ public class TimeoutMapTest extends MapAbstractTest {
            }
        }

-        assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
+        assertTrue("Elements expired too early, test did not run as expected.", count > 0);
        //assertEquals("Elements did not expire as expected.", 1, count);
    }

@@ -571,7 +573,7 @@ public class TimeoutMapTest extends MapAbstractTest {
            }
        }

-        assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
+        assertTrue("Elements expired too early, test did not run as expected.", count > 0);
        //assertEquals("Elements did not expire as expected.", 1, count);
    }

@@ -611,7 +613,7 @@ public class TimeoutMapTest extends MapAbstractTest {
            }
        }

-        assertTrue(count > 0, "Elements expired too early, test did not run as expected.");
+        assertTrue("Elements expired too early, test did not run as expected.", count > 0);
        //assertEquals("Elements did not expire as expected.", 1, count);
    }

@@ -628,7 +630,7 @@ public class TimeoutMapTest extends MapAbstractTest {
        Object removedKey = null;
        Object otherKey = null;
        Iterator iterator = map.entrySet().iterator();
-        assertTrue(iterator.hasNext(), "Iterator was empty");
+        assertTrue("Iterator was empty", iterator.hasNext());
        try {
            Map.Entry entry = (Map.Entry) iterator.next();
            assertNotNull(entry);
@@ -646,8 +648,8 @@ public class TimeoutMapTest extends MapAbstractTest {
            fail("Elements expired between Interator.hasNext() and Iterator.remove()");
        }

-        assertTrue(!map.containsKey(removedKey), "Wrong entry removed, keySet().iterator() is broken.");
-        assertTrue(map.containsKey(otherKey), "Wrong entry removed, keySet().iterator() is broken.");
+        assertTrue("Wrong entry removed, keySet().iterator() is broken.", !map.containsKey(removedKey));
+        assertTrue("Wrong entry removed, keySet().iterator() is broken.", map.containsKey(otherKey));
    }


@@ -30,10 +30,12 @@

 package com.twelvemonkeys.util;

+import org.junit.Test;
+
 import java.util.Iterator;

-import org.junit.jupiter.api.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.fail;

 /**
 * TokenIteratorAbstractTestCase
@@ -78,7 +80,7 @@ public abstract class TokenIteratorAbstractTest {
    @Test
    public void testEmptyString() {
        Iterator iterator = createTokenIterator("");
-        assertFalse(iterator.hasNext(), "Empty string has elements");
+        assertFalse("Empty string has elements", iterator.hasNext());
    }

 }
@@ -30,8 +30,8 @@

 package com.twelvemonkeys.util.convert;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
+import org.junit.Ignore;
+import org.junit.Test;

 /**
 * ConverterTest
@@ -43,7 +43,7 @@ import org.junit.jupiter.api.Test;
 */
 public class ConverterTest {

-    @Disabled("Not implemented")
+    @Ignore("Not implemented")
    @Test
    public void testMe() {
        // TODO: Implement tests
@@ -31,7 +31,7 @@
 package com.twelvemonkeys.util.convert;

 import com.twelvemonkeys.lang.DateUtil;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;

 import java.text.DateFormat;
 import java.util.Date;
@@ -31,13 +31,13 @@
 package com.twelvemonkeys.util.convert;

 import com.twelvemonkeys.lang.Validate;
+import org.junit.Ignore;
+import org.junit.Test;

 import java.io.File;
 import java.net.URI;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * DefaultConverterTest
@@ -138,7 +138,7 @@ public class DefaultConverterTest extends PropertyConverterAbstractTest {
        assertEquals(-2.3456, (Double) converter.toObject("-2.3456", Double.TYPE, null), 0);
    }

-    @Disabled("Known issue. Why would anyone do something like this?")
+    @Ignore("Known issue. Why would anyone do something like this?")
    @Test
    public void testConvertCharPrimitive() {
        PropertyConverter converter = makePropertyConverter();
@@ -32,11 +32,11 @@ package com.twelvemonkeys.util.convert;

 import com.twelvemonkeys.lang.ObjectAbstractTest;
 import com.twelvemonkeys.lang.Validate;
+import org.junit.Test;

 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * PropertyConverterAbstractTest
@@ -66,26 +66,26 @@ public abstract class PropertyConverterAbstractTest extends ObjectAbstractTest {
            try {
                obj = converter.toObject(test.original(), test.type(), test.format());

-                assertEquals(test.type(), obj.getClass(), String.format("'%s' converted to incorrect type", test.original()));
+                assertEquals(String.format("'%s' converted to incorrect type", test.original()), test.type(), obj.getClass());
                if (test.type().isArray()) {
                    assertArrayEquals0(String.format("'%s' not converted", test.original()), test.value(), obj);
                }
                else {
-                    assertEquals(test.value(), obj, String.format("'%s' not converted", test.original()));
+                    assertEquals(String.format("'%s' not converted", test.original()), test.value(), obj);
                }

                String result = converter.toString(test.value(), test.format());

-                assertEquals(test.converted(), result, String.format("'%s' does not match", test.converted()));
+                assertEquals(String.format("'%s' does not match", test.converted()), test.converted(), result);

                obj = converter.toObject(result, test.type(), test.format());
-                assertEquals(test.type(), obj.getClass(), String.format("'%s' converted to incorrect type", test.original()));
+                assertEquals(String.format("'%s' converted to incorrect type", test.original()), test.type(), obj.getClass());

                if (test.type().isArray()) {
                    assertArrayEquals0(String.format("'%s' did not survive round trip conversion", test.original()), test.value(), obj);
                }
                else {
-                    assertEquals(test.value(), obj, String.format("'%s' did not survive round trip conversion", test.original()));
+                    assertEquals(String.format("'%s' did not survive round trip conversion", test.original()), test.value(), obj);
                }
            }
            catch (ConversionException e) {
@@ -98,35 +98,35 @@ public abstract class PropertyConverterAbstractTest extends ObjectAbstractTest {
        Class<?> componentType = left.getClass().getComponentType();
        if (componentType.isPrimitive()) {
            if (int.class == componentType) {
-                assertArrayEquals((int[]) left, (int[]) right, message);
+                assertArrayEquals(message, (int[]) left, (int[]) right);
            }
            else if (short.class == componentType) {
-                assertArrayEquals((short[]) left, (short[]) right, message);
+                assertArrayEquals(message, (short[]) left, (short[]) right);
            }
            else if (long.class == componentType) {
-                assertArrayEquals((long[]) left, (long[]) right, message);
+                assertArrayEquals(message, (long[]) left, (long[]) right);
            }
            else if (float.class == componentType) {
-                assertArrayEquals((float[]) left, (float[]) right, 0f, message);
+                assertArrayEquals(message, (float[]) left, (float[]) right, 0f);
            }
            else if (double.class == componentType) {
-                assertArrayEquals((double[]) left, (double[]) right, 0d, message);
+                assertArrayEquals(message, (double[]) left, (double[]) right, 0d);
            }
            else if (boolean.class == componentType) {
-                assertTrue(Arrays.equals((boolean[]) left, (boolean[]) right), message);
+                assertTrue(message, Arrays.equals((boolean[]) left, (boolean[]) right));
            }
            else if (byte.class == componentType) {
-                assertArrayEquals((byte[]) left, (byte[]) right, message);
+                assertArrayEquals(message, (byte[]) left, (byte[]) right);
            }
            else if (char.class == componentType) {
-                assertArrayEquals((char[]) left, (char[]) right, message);
+                assertArrayEquals(message, (char[]) left, (char[]) right);
            }
            else {
                fail(String.format("Unknown primitive type: %s", componentType));
            }
        }
        else {
-            assertArrayEquals((Object[]) left, (Object[]) right, message);
+            assertArrayEquals(message, (Object[]) left, (Object[]) right);
        }
    }

@@ -32,11 +32,12 @@ package com.twelvemonkeys.util.regex;

 import com.twelvemonkeys.util.TokenIterator;
 import com.twelvemonkeys.util.TokenIteratorAbstractTest;
+import org.junit.Test;

 import java.util.Iterator;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
+
 /**
 * StringTokenIteratorTestCase
 * <p/>
@@ -67,9 +68,9 @@ public class RegExTokenIteratorTest extends TokenIteratorAbstractTest {
    @Test
    public void testSingleToken() {
        Iterator iterator = createTokenIterator("A");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
@@ -86,67 +87,67 @@ public class RegExTokenIteratorTest extends TokenIteratorAbstractTest {
    @Test
    public void testSingleTokenSingleDelimiter() {
        Iterator iterator = createTokenIterator("A", "[^,]+");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleSeparatorDefaultDelimiter() {
        Iterator iterator = createTokenIterator("A B C D");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testSingleSeparator() {
        Iterator iterator = createTokenIterator("A,B,C", "[^,]+");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testMultipleSeparatorDefaultDelimiter() {
        Iterator iterator = createTokenIterator("A B   C\nD\t\t \nE");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("A", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("E", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }

    @Test
    public void testMultipleSeparator() {
        Iterator iterator = createTokenIterator("A,B,;,C...D, ., ,E", "[^ ,.;:]+");
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        Object o = iterator.next();
        assertEquals("A", o);
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("B", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("C", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("D", iterator.next());
-        assertTrue(iterator.hasNext(), "String has no elements");
+        assertTrue("String has no elements", iterator.hasNext());
        assertEquals("E", iterator.next());
-        assertFalse(iterator.hasNext(), "String has more than one element");
+        assertFalse("String has more than one element", iterator.hasNext());
    }
 }
@@ -30,13 +30,12 @@

 package com.twelvemonkeys.util.service;

-import com.twelvemonkeys.lang.Validate;
 import com.twelvemonkeys.util.CollectionUtil;
+import org.junit.Test;

 import java.util.*;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * ServiceRegistryTest
@@ -49,11 +48,9 @@ public class ServiceRegistryTest {

    private final TestRegistry registry = new TestRegistry();

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNull() {
-        assertThrows(IllegalArgumentException.class, () -> {
-            new ServiceRegistry(null);
-        });
+        new ServiceRegistry(null);
    }

    @Test
@@ -67,12 +64,11 @@ public class ServiceRegistryTest {
        }
    }

-    @Test
+    @Test(expected = ServiceConfigurationError.class)
    public void testCreateBadConfig() {
-        assertThrows(ServiceConfigurationError.class, () -> {
-            ServiceRegistry registry = new ServiceRegistry(Arrays.asList(BadSPI.class).iterator());
-            registry.registerApplicationClasspathSPIs();
-        });
+        @SuppressWarnings("unchecked") 
+        ServiceRegistry registry = new ServiceRegistry(Arrays.asList(BadSPI.class).iterator());
+        registry.registerApplicationClasspathSPIs();

        // DONE: Test non-class

@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.common</groupId>
    <artifactId>common</artifactId>
@@ -20,10 +20,6 @@
        <module>common-image</module>
    </modules>

-    <properties>
-        <junit.jupiter.version>5.14.3</junit.jupiter.version>
-    </properties>
-
    <dependencyManagement>
        <dependencies>
            <dependency>
@@ -47,18 +43,11 @@
            </dependency>
        </dependencies>
    </dependencyManagement>
-
    <dependencies>
        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit.jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-params</artifactId>
-            <version>${junit.jupiter.version}</version>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys</groupId>
        <artifactId>twelvemonkeys</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <groupId>com.twelvemonkeys.contrib</groupId>
    <artifactId>contrib</artifactId>
@@ -13,11 +13,6 @@
      Contributions to TwelveMonkeys and code that doesn't fit anywhere else.
    </description>

-    <properties>
-        <junit.jupiter.version>5.14.3</junit.jupiter.version>
-    </properties>
-
-
    <dependencies>
        <dependency>
            <groupId>com.twelvemonkeys.common</groupId>
@@ -66,16 +61,11 @@
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
+        
        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit.jupiter.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <version>${junit.jupiter.version}</version>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
@@ -1,9 +1,9 @@
 package com.twelvemonkeys.contrib.exif;

-import static com.twelvemonkeys.contrib.exif.Orientation.*;
+import org.junit.Test;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.twelvemonkeys.contrib.exif.Orientation.*;
+import static org.junit.Assert.assertEquals;

 /**
 * OrientationTest.
@@ -34,6 +34,8 @@ import com.twelvemonkeys.contrib.tiff.TIFFUtilities.TIFFExtension;
 import com.twelvemonkeys.imageio.plugins.tiff.TIFFImageMetadataFormat;
 import com.twelvemonkeys.io.FileUtil;

+import org.junit.Assert;
+import org.junit.Test;
 import org.w3c.dom.Node;

 import javax.imageio.ImageIO;
@@ -52,9 +54,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
 /**
 * TIFFUtilitiesTest
 *
@@ -96,7 +95,7 @@ public class TIFFUtilitiesTest {
        ImageInputStream iis = ImageIO.createImageInputStream(output);
        ImageReader reader = ImageIO.getImageReaders(iis).next();
        reader.setInput(iis);
-        assertEquals(3, reader.getNumImages(true));
+        Assert.assertEquals(3, reader.getNumImages(true));

        iis.close();
        output.delete();
@@ -120,11 +119,11 @@ public class TIFFUtilitiesTest {
        ImageReader reader = ImageIO.getImageReadersByFormatName("TIF").next();

        File[] outputFiles = outputDirectory.listFiles();
-        assertEquals(3, outputFiles.length);
+        Assert.assertEquals(3, outputFiles.length);
        for (File outputFile : outputFiles) {
            ImageInputStream iis = ImageIO.createImageInputStream(outputFile);
            reader.setInput(iis);
-            assertEquals(1, reader.getNumImages(true));
+            Assert.assertEquals(1, reader.getNumImages(true));
            iis.close();
            outputFile.delete();
        }
@@ -158,7 +157,7 @@ public class TIFFUtilitiesTest {
            Node metaData = reader.getImageMetadata(i)
                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
-            assertEquals(orientation, TIFFExtension.ORIENTATION_RIGHTTOP);
+            Assert.assertEquals(orientation, TIFFExtension.ORIENTATION_RIGHTTOP);
        }
        checkTest1.close();

@@ -175,7 +174,7 @@ public class TIFFUtilitiesTest {
            Node metaData = reader.getImageMetadata(i)
                    .getAsTree(TIFFImageMetadataFormat.SUN_NATIVE_IMAGE_METADATA_FORMAT_NAME);
            short orientation = ((Number) expression.evaluate(metaData, XPathConstants.NUMBER)).shortValue();
-            assertEquals(orientation, i == 1
+            Assert.assertEquals(orientation, i == 1
                                             ? TIFFExtension.ORIENTATION_BOTRIGHT
                                             : TIFFExtension.ORIENTATION_RIGHTTOP);
        }
@@ -200,7 +199,7 @@ public class TIFFUtilitiesTest {
        byte[] original = ((DataBufferByte) image.getData().getDataBuffer()).getData();
        byte[] rotated = ((DataBufferByte) image360.getData().getDataBuffer()).getData();

-        assertArrayEquals(original, rotated);
+        Assert.assertArrayEquals(original, rotated);
    }

    @Test
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-batik</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Batik Plugin</name>
@@ -17,7 +17,7 @@

    <properties>
        <project.jpms.module.name>com.twelvemonkeys.imageio.batik</project.jpms.module.name>
-        <batik.version>1.19</batik.version>
+        <batik.version>1.17</batik.version>
    </properties>

    <build>
@@ -63,7 +63,7 @@
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
-            <version>2.21.0</version>
+            <version>2.15.0</version>
            <scope>provided</scope>
        </dependency>

@@ -36,11 +36,9 @@ import com.twelvemonkeys.lang.SystemUtil;
 import javax.imageio.ImageReader;
 import javax.imageio.spi.ServiceRegistry;
 import javax.imageio.stream.ImageInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.EOFException;
 import java.io.IOException;
 import java.util.Locale;
-import java.util.function.Predicate;

 import static com.twelvemonkeys.imageio.util.IIOUtil.deregisterProvider;

@@ -136,42 +134,10 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {
                    if (buffer[0] == 's' && buffer[1] == 'v' && buffer[2] == 'g'
                            && (Character.isWhitespace((char) buffer[3]) || buffer[3] == ':')) {
                        // It's SVG, identified by root tag
+                        // TODO: Support svg with prefix + recognize namespace (http://www.w3.org/2000/svg)!
                        return true;
                    }

-                    // Read the full tag name (may contain a prefix of any length)
-                    final int MAX_TAG_NAME = 256;
-                    ByteArrayOutputStream nameBuf = new ByteArrayOutputStream(MAX_TAG_NAME);
-
-                    // We already have 4 bytes in 'buffer' (from input.readFully(buffer))
-                    int consumedFromBuffer = 0;
-                    for (; consumedFromBuffer < buffer.length; consumedFromBuffer++) {
-                        byte bb = buffer[consumedFromBuffer];
-                        if (bb == '>' || Character.isWhitespace((char) bb) || bb == '/') {
-                            break;
-                        }
-                        nameBuf.write(bb);
-                    }
-
-                    // If tag name not terminated yet, keep reading bytes (within limit)
-                    final boolean incompleteTagName = consumedFromBuffer == buffer.length;
-                    readBuffer(input, nameBuf, output -> incompleteTagName && output.size() < MAX_TAG_NAME,
-                        bb -> bb == '>' || Character.isWhitespace(bb) || bb == '/');
-
-                    final String name = nameBuf.toString("US-ASCII");
-                    if (name.toLowerCase(Locale.ENGLISH).endsWith(":svg")) {
-                        // Scan the rest of the tag attributes until '>' to find the SVG namespace URI
-                        ByteArrayOutputStream attrBuf = new ByteArrayOutputStream();
-                        final int MAX_ATTR_SCAN = 1024; // safe upper bound to keep it fast
-                        readBuffer(input, attrBuf, output -> output.size() < MAX_ATTR_SCAN, bb -> bb == '>');
-
-                        // If the tag contains the SVG namespace, it's SVG.
-                        if (attrBuf.toString("US-ASCII").matches(
-                            ".*xmlns:" + name.split(":")[0] + "\\s*=\\s*\"http://www.w3.org/2000/svg\".*")) {
-                            return true;
-                        }
-                    }
-
                    // If the tag is not "svg", this isn't SVG
                    return false;
                }
@@ -191,17 +157,6 @@ public final class SVGImageReaderSpi extends ImageReaderSpiBase {
        }
    }

-    private static void readBuffer(final ImageInputStream input, final ByteArrayOutputStream buffer,
-            final Predicate<ByteArrayOutputStream> loopCondition, Predicate<Byte> breakCondition) throws IOException {
-        while (loopCondition.test(buffer)) {
-            byte bb = input.readByte();
-            if (breakCondition.test(bb)) {
-                break;
-            }
-            buffer.write(bb);
-        }
-    }
-
    public ImageReader createReaderInstance(final Object extension) throws IOException {
        return new SVGImageReader(this);
    }
@@ -32,16 +32,16 @@ package com.twelvemonkeys.imageio.plugins.svg;

 import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
 import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
+import org.junit.Test;

 import javax.imageio.ImageIO;
 import javax.imageio.spi.IIORegistry;
 import javax.imageio.spi.ImageReaderSpi;
 import javax.imageio.stream.ImageInputStream;
 import java.nio.charset.StandardCharsets;
-import java.time.Duration;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;

 /**
 * SVGImageReaderSpiTest.
@@ -56,7 +56,7 @@ public class SVGImageReaderSpiTest {
            "/svg/Android_robot.svg", // Minimal, no xml dec, no namespace
            "/svg/batikLogo.svg",     // xml dec, comments, namespace
            "/svg/blue-square.svg",   // xml dec, namespace
-            "/svg/red-square.svg",    // prefixed namespace
+            "/svg/red-square.svg",
    };

    private static final String[] INVALID_INPUTS = {
@@ -70,9 +70,6 @@ public class SVGImageReaderSpiTest {
        "<!-- ", // #275 Infinite loop issue
        "<?123?>", // #275 Infinite loop issue
        "<svg",
-        "<ns0:svg>", // namespace prefix undefined
-        "<ns0:svg xmlns:ns0=\"foo\">", // not the official svg namespace
-        "<ns0:svg xmlns:ns1=\"http://www.w3.org/2000/svg\">", // mismatching prefix
    };

    static {
@@ -86,20 +83,18 @@ public class SVGImageReaderSpiTest {
    public void canDecodeInput() throws Exception {
        for (String validInput : VALID_INPUTS) {
            try (ImageInputStream input = ImageIO.createImageInputStream(getClass().getResource(validInput))) {
-                assertTrue(provider.canDecodeInput(input), "Can't read valid input: " + validInput);
+                assertTrue("Can't read valid input: " + validInput, provider.canDecodeInput(input));
            }
        }
    }

    // Test will time out, if EOFs are not properly detected, see #275
-    @Test
+    @Test(timeout = 5000)
    public void canDecodeInputInvalid() throws Exception {
-        assertTimeoutPreemptively(Duration.ofMillis(5000), () -> {
-            for (String invalidInput : INVALID_INPUTS) {
-                try (ImageInputStream input = new ByteArrayImageInputStream(invalidInput.getBytes(StandardCharsets.UTF_8))) {
-                    assertFalse(provider.canDecodeInput(input), "Claims to read invalid input:" + invalidInput);
-                }
+        for (String invalidInput : INVALID_INPUTS) {
+            try (ImageInputStream input = new ByteArrayImageInputStream(invalidInput.getBytes(StandardCharsets.UTF_8))) {
+                assertFalse("Claims to read invalid input:" + invalidInput, provider.canDecodeInput(input));
            }
-        });
+        }
    }
 }
@@ -32,6 +32,9 @@ package com.twelvemonkeys.imageio.plugins.svg;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import javax.imageio.IIOException;
 import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
@@ -49,9 +52,10 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.*;

 /**
@@ -124,18 +128,18 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
                int current = image.getRGB(x, y);
                if (x < quadPoint) {
                    if (y < quadPoint) {
-                        assertEquals( 0xFF0000FF, current, "x=" + x + " y=" + y + " q=" + quadPoint);
+                        assertEquals("x=" + x + " y=" + y + " q=" + quadPoint, 0xFF0000FF, current);
                    }
                    else {
-                        assertEquals(0xFFFF0000, current, "x=" + x + " y=" + y + " q=" + quadPoint);
+                        assertEquals("x=" + x + " y=" + y + " q=" + quadPoint, 0xFFFF0000, current);
                    }
                }
                else {
                    if (y < quadPoint) {
-                        assertEquals(0xFF00FF00, current, "x=" + x + " y=" + y + " q=" + quadPoint);
+                        assertEquals("x=" + x + " y=" + y + " q=" + quadPoint, 0xFF00FF00, current);
                    }
                    else {
-                        assertEquals(0xFF000000, current, "x=" + x + " y=" + y + " q=" + quadPoint);
+                        assertEquals("x=" + x + " y=" + y + " q=" + quadPoint, 0xFF000000, current);
                    }
                }
            }
@@ -167,14 +171,14 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
    }

    @Test
-    @Disabled("Known issue: Source region reading not supported")
+    @Ignore("Known issue: Source region reading not supported")
    @Override
    public void testReadWithSourceRegionParamEqualImage() throws IOException {
        super.testReadWithSourceRegionParamEqualImage();
    }

    @Test
-    @Disabled("Known issue: Subsampled reading not supported")
+    @Ignore("Known issue: Subsampled reading not supported")
    @Override
    public void testReadWithSubsampleParamPixels() throws IOException {
        super.testReadWithSubsampleParamPixels();
@@ -312,7 +316,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
        }
    }

-    @Test
+    @Test(expected = SecurityException.class)
    public void testDisallowedExternalResources() throws URISyntaxException, IOException {
        // system-property set to true in surefire-plugin-settings in the pom
        URL resource = getClassLoaderResource("/svg/barChart.svg");
@@ -329,9 +333,7 @@ public class SVGImageReaderTest extends ImageReaderAbstractTest<SVGImageReader>
            // `reader.read` for `/svg/barChart.svg` should raise
            // a SecurityException when External Resources are blocked
            // because the API invocation gets preference
-            assertThrows(SecurityException.class, () -> {
-                reader.read(0, param);
-            });
+            reader.read(0, param);
        }
        finally {
            reader.dispose();
@@ -32,6 +32,9 @@ package com.twelvemonkeys.imageio.plugins.wmf;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
 import java.io.IOException;
@@ -39,8 +42,6 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
 /**
 * WMFImageReaderTest
 *
@@ -76,14 +77,14 @@ public class WMFImageReaderTest extends ImageReaderAbstractTest<WMFImageReader>
    }

    @Test
-    @Disabled("Known issue: Source region reading not supported")
+    @Ignore("Known issue: Source region reading not supported")
    @Override
    public void testReadWithSourceRegionParamEqualImage() throws IOException {
        super.testReadWithSourceRegionParamEqualImage();
    }

    @Test
-    @Disabled("Known issue: Subsampled reading not supported")
+    @Ignore("Known issue: Subsampled reading not supported")
    @Override
    public void testReadWithSubsampleParamPixels() throws IOException {
        super.testReadWithSubsampleParamPixels();
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<ns0:svg xmlns:ns0="http://www.w3.org/2000/svg" width="100" height="100" id="red-square" version="1.1">
-  <ns0:g id="layer1">
-    <ns0:rect id="rect2985" width="100" height="100" x="0" y="0"
+<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" id="red-square" version="1.1">
+  <g id="layer1">
+    <rect id="rect2985" width="100" height="100" x="0" y="0"
       style="color:#000000;fill:#ff0000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:1;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
-  </ns0:g>
-</ns0:svg>
+  </g>
+</svg>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-bmp</artifactId>
    <name>TwelveMonkeys :: ImageIO :: BMP plugin</name>
@@ -33,8 +33,8 @@ package com.twelvemonkeys.imageio.plugins.bmp;
 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;
 import com.twelvemonkeys.xml.XMLSerializer;

-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.Disabled;
+import org.junit.Ignore;
+import org.junit.Test;
 import org.mockito.InOrder;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
@@ -59,8 +59,8 @@ import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;

-import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeNoException;
 import static org.mockito.ArgumentMatchers.anyFloat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.atLeastOnce;
@@ -204,11 +204,11 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                }
            }

-            assertTrue(rawFound, "ImageTypeSepcifier from getRawImageType should be in the iterator from getImageTypes");
+            assertTrue("ImageTypeSepcifier from getRawImageType should be in the iterator from getImageTypes", rawFound);
        }
    }

-    @Disabled("Known issue: Subsampled reading is currently broken")
+    @Ignore("Known issue: Subsampled reading is currently broken")
    @Test
    public void testReadWithSubsampleParamPixelsIndexed8() throws IOException {
        ImageReader reader = createReader();
@@ -235,7 +235,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
    // TODO: 1. Subsampling is currently broken, should fix it.
    //       2. BMPs are (normally) stored bottom/up, meaning y subsampling offsets will differ from normal
    //          subsampling of the same data with an offset... Should we deal with this in the reader? Yes?
-    @Disabled("Known issue: Subsampled reading is currently broken")
+    @Ignore("Known issue: Subsampled reading is currently broken")
    @Test
    @Override
    public void testReadWithSubsampleParamPixels() throws IOException {
@@ -260,7 +260,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        assertSubsampledImageDataEquals("Subsampled image data does not match expected", image, subsampled, param);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testReadCorruptCausesIIOException() throws IOException {
        // See https://bugs.openjdk.java.net/browse/JDK-8066904
        // NullPointerException when calling ImageIO.read(InputStream) with corrupt BMP
@@ -268,9 +268,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>

        try {
            reader.setInput(ImageIO.createImageInputStream(getClassLoaderResource("/broken-bmp/corrupted-bmp.bmp")));
-            assertThrows(IIOException.class, () -> {
-                reader.read(0);
-            });
+            reader.read(0);
        }
        finally {
            reader.dispose();
@@ -333,7 +331,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
        catch (Exception e) {
            e.printStackTrace();
            // Ignore this test if not on an Oracle JRE (com.sun...BMPImageReader not available)
-            assumeTrue(false, "Skipping test: BMPImageReaderSpi not available on non-Oracle JREs");
+            assumeNoException(e);
            return;
        }

@@ -385,7 +383,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                    new XMLSerializer(expected, "UTF-8").serialize(expectedTree, false);
                    new XMLSerializer(actual, "UTF-8").serialize(actualTree, false);

-                    assertEquals(new String(expected.toByteArray(), StandardCharsets.UTF_8), new String(actual.toByteArray(), StandardCharsets.UTF_8), e.getMessage());
+                    assertEquals(e.getMessage(), new String(expected.toByteArray(), StandardCharsets.UTF_8), new String(actual.toByteArray(), StandardCharsets.UTF_8));

                    throw e;
                }
@@ -394,24 +392,24 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
    }

    private void assertNodeEquals(final String message, final Node expected, final Node actual) {
-        assertEquals(expected.getClass(), actual.getClass(), message + " class differs");
+        assertEquals(message + " class differs", expected.getClass(), actual.getClass());

        if (!excludeEqualValueTest(expected)) {
-            assertEquals(expected.getNodeValue(), actual.getNodeValue(), message);
+            assertEquals(message, expected.getNodeValue(), actual.getNodeValue());

            if (expected instanceof IIOMetadataNode) {
                IIOMetadataNode expectedIIO = (IIOMetadataNode) expected;
                IIOMetadataNode actualIIO = (IIOMetadataNode) actual;

-                assertEquals(expectedIIO.getUserObject(), actualIIO.getUserObject(), message);
+                assertEquals(message, expectedIIO.getUserObject(), actualIIO.getUserObject());
            }
        }

        NodeList expectedChildNodes = expected.getChildNodes();
        NodeList actualChildNodes = actual.getChildNodes();

-        assertTrue(expectedChildNodes.getLength() <= actualChildNodes.getLength(),
-                message + " child length differs: " + toString(expectedChildNodes) + " != " + toString(actualChildNodes));
+        assertTrue(message + " child length differs: " + toString(expectedChildNodes) + " != " + toString(actualChildNodes),
+                expectedChildNodes.getLength() <= actualChildNodes.getLength());

        for (int i = 0; i < expectedChildNodes.getLength(); i++) {
            Node expectedChild = expectedChildNodes.item(i);
@@ -425,7 +423,7 @@ public class BMPImageReaderTest extends ImageReaderAbstractTest<BMPImageReader>
                }
            }

-            assertEquals(expectedChild.getLocalName(), actualChild.getLocalName(), message + " node name differs");
+            assertEquals(message + " node name differs", expectedChild.getLocalName(), actualChild.getLocalName());
            assertNodeEquals(message + "/" + expectedChild.getLocalName(), expectedChild, actualChild);
        }
    }
@@ -32,6 +32,9 @@ package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import javax.imageio.ImageReadParam;
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
@@ -41,9 +44,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * CURImageReaderTest
@@ -92,16 +93,16 @@ public class CURImageReaderTest extends ImageReaderAbstractTest<CURImageReader>
        if (hotspot != Image.UndefinedProperty || pParam == null) {

            // Typically never happens, because of weirdness with UndefinedProperty
-            assertNotNull(hotspot, "Hotspot for cursor not present");
+            assertNotNull("Hotspot for cursor not present", hotspot);

            // Image weirdness
-            assertNotSame(Image.UndefinedProperty, hotspot, "Hotspot for cursor undefined (java.awt.Image.UndefinedProperty)");
+            assertNotSame("Hotspot for cursor undefined (java.awt.Image.UndefinedProperty)", Image.UndefinedProperty, hotspot);

-            assertTrue(hotspot instanceof Point, String.format("Hotspot not a java.awt.Point: %s", hotspot.getClass()));
+            assertTrue(String.format("Hotspot not a java.awt.Point: %s", hotspot.getClass()), hotspot instanceof Point);
            assertEquals(pExpected, hotspot);
        }

-        assertNotNull(reader.getHotSpot(0), "Hotspot for cursor not present");
+        assertNotNull("Hotspot for cursor not present", reader.getHotSpot(0));
        assertEquals(pExpected, reader.getHotSpot(0));
    }

@@ -140,14 +141,14 @@ public class CURImageReaderTest extends ImageReaderAbstractTest<CURImageReader>
    // TODO: Test cursor is transparent

    @Test
-    @Disabled("Known issue")
+    @Ignore("Known issue")
    @Override
    public void testNotBadCaching() throws IOException {
        super.testNotBadCaching();
    }

    @Test
-    @Disabled("Known issue: Subsampled reading currently not supported")
+    @Ignore("Known issue: Subsampled reading currently not supported")
    @Override
    public void testReadWithSubsampleParamPixels() throws IOException {
        super.testReadWithSubsampleParamPixels();
@@ -32,6 +32,9 @@ package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.imageio.util.ImageReaderAbstractTest;

+import org.junit.Ignore;
+import org.junit.Test;
+
 import javax.imageio.spi.ImageReaderSpi;
 import java.awt.*;
 import java.io.IOException;
@@ -39,9 +42,6 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
 /**
 * ICOImageReaderTest
 *
@@ -98,14 +98,14 @@ public class ICOImageReaderTest extends ImageReaderAbstractTest<ICOImageReader>
    }

    @Test
-    @Disabled("Known issue")
+    @Ignore("Known issue")
    @Override
    public void testNotBadCaching() throws IOException {
        super.testNotBadCaching();
    }

    @Test
-    @Disabled("Known issue: Subsampled reading currently not supported")
+    @Ignore("Known issue: Subsampled reading currently not supported")
    @Override
    public void testReadWithSubsampleParamPixels() throws IOException {
        super.testReadWithSubsampleParamPixels();
@@ -32,6 +32,7 @@ package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.io.enc.Decoder;
 import com.twelvemonkeys.io.enc.DecoderStream;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -41,8 +42,8 @@ import java.nio.channels.Channels;
 import java.nio.channels.ReadableByteChannel;
 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;

 public class RLE4DecoderTest {

@@ -81,8 +82,8 @@ public class RLE4DecoderTest {
            int r = channel.read(plain);
            plain.rewind();

-            assertEquals(r, d, "Difference at line " + i);
-            assertArrayEquals(plain.array(), decoded.array(), "Difference at line " + i);
+            assertEquals("Difference at line " + i, r, d);
+            assertArrayEquals("Difference at line " + i, plain.array(), decoded.array());
        }
    }

@@ -103,7 +104,7 @@ public class RLE4DecoderTest {
        int pos = 0;
        while (true) {
            int expected = plainSream.read();
-            assertEquals(expected, decoded.read(), "Differs at " + pos);
+            assertEquals("Differs at " + pos, expected, decoded.read());

            if (expected < 0) {
                break;
@@ -32,6 +32,7 @@ package com.twelvemonkeys.imageio.plugins.bmp;

 import com.twelvemonkeys.io.enc.Decoder;
 import com.twelvemonkeys.io.enc.DecoderStream;
+import org.junit.Test;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -41,8 +42,8 @@ import java.nio.channels.Channels;
 import java.nio.channels.ReadableByteChannel;
 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;

 public class RLE8DecoderTest {

@@ -107,7 +108,7 @@ public class RLE8DecoderTest {
        while (true) {
            int expected = plainSream.read();

-            assertEquals(expected, decoded.read(), "Differs at " + pos);
+            assertEquals("Differs at " + pos, expected, decoded.read());

            if (expected < 0) {
                break;
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-clippath</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Photoshop Path Support</name>
@@ -30,6 +30,8 @@

 package com.twelvemonkeys.imageio.path;

+import org.junit.Test;
+
 import javax.imageio.IIOException;
 import javax.imageio.stream.ImageInputStream;
 import java.awt.geom.Path2D;
@@ -37,39 +39,36 @@ import java.io.DataInput;
 import java.io.IOException;
 import java.nio.ByteBuffer;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
 import static com.twelvemonkeys.imageio.path.PathsTest.assertPathEquals;
 import static com.twelvemonkeys.imageio.path.PathsTest.readExpectedPath;
+import static org.junit.Assert.assertNotNull;

@SuppressWarnings("deprecation")
 public class AdobePathBuilderTest {

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNullBytes() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathBuilder((byte[]) null));
-
+        new AdobePathBuilder((byte[]) null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNull() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathBuilder((DataInput) null));
+        new AdobePathBuilder((DataInput) null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateEmpty() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathBuilder(new byte[0]));
+        new AdobePathBuilder(new byte[0]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateShortPath() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathBuilder(new byte[3]));
+        new AdobePathBuilder(new byte[3]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateImpossiblePath() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathBuilder(new byte[7]));
+        new AdobePathBuilder(new byte[7]);
    }

    @Test
@@ -83,20 +82,18 @@ public class AdobePathBuilderTest {
        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testShortPath() throws IOException {
        byte[] data = new byte[26];
        ByteBuffer buffer = ByteBuffer.wrap(data);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD);
        buffer.putShort((short) 1);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathBuilder(data).path();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathBuilder(data).path();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testShortPathToo() throws IOException {
        byte[] data = new byte[52];
        ByteBuffer buffer = ByteBuffer.wrap(data);
@@ -105,13 +102,11 @@ public class AdobePathBuilderTest {
        buffer.position(buffer.position() + 22);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathBuilder(data).path();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathBuilder(data).path();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testLongPath() throws IOException {
        byte[] data = new byte[78];
        ByteBuffer buffer = ByteBuffer.wrap(data);
@@ -122,22 +117,18 @@ public class AdobePathBuilderTest {
        buffer.position(buffer.position() + 24);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathBuilder(data).path();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathBuilder(data).path();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testPathMissingLength() throws IOException {
        byte[] data = new byte[26];
        ByteBuffer buffer = ByteBuffer.wrap(data);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathBuilder(data).path();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathBuilder(data).path();
+        assertNotNull(path);
    }

    @Test
@@ -31,6 +31,7 @@

 package com.twelvemonkeys.imageio.path;

+import org.junit.Test;

 import javax.imageio.IIOException;
 import javax.imageio.stream.ImageInputStream;
@@ -38,37 +39,36 @@ import java.awt.geom.Path2D;
 import java.io.DataInput;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import org.junit.jupiter.api.Test;

-import static org.junit.jupiter.api.Assertions.*;
 import static com.twelvemonkeys.imageio.path.PathsTest.assertPathEquals;
 import static com.twelvemonkeys.imageio.path.PathsTest.readExpectedPath;
+import static org.junit.Assert.assertNotNull;

 public class AdobePathReaderTest {

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNullBytes() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathReader((byte[]) null));
+        new AdobePathReader((byte[]) null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNull() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathReader((DataInput) null));
+        new AdobePathReader((DataInput) null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateEmpty() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathReader(new byte[0]));
+        new AdobePathReader(new byte[0]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateShortPath() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathReader(new byte[3]));
+        new AdobePathReader(new byte[3]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateImpossiblePath() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathReader(new byte[7]));
+        new AdobePathReader(new byte[7]);
    }

    @Test
@@ -82,20 +82,18 @@ public class AdobePathReaderTest {
        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testShortPath() throws IOException {
        byte[] data = new byte[26];
        ByteBuffer buffer = ByteBuffer.wrap(data);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD);
        buffer.putShort((short) 1);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathReader(data).readPath();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathReader(data).readPath();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testShortPathToo() throws IOException {
        byte[] data = new byte[52];
        ByteBuffer buffer = ByteBuffer.wrap(data);
@@ -104,13 +102,11 @@ public class AdobePathReaderTest {
        buffer.position(buffer.position() + 22);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathReader(data).readPath();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathReader(data).readPath();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testLongPath() throws IOException {
        byte[] data = new byte[78];
        ByteBuffer buffer = ByteBuffer.wrap(data);
@@ -121,22 +117,18 @@ public class AdobePathReaderTest {
        buffer.position(buffer.position() + 24);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathReader(data).readPath();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathReader(data).readPath();
+        assertNotNull(path);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testPathMissingLength() throws IOException {
        byte[] data = new byte[26];
        ByteBuffer buffer = ByteBuffer.wrap(data);
        buffer.putShort((short) AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED);

-        assertThrows(IIOException.class, () -> {
-            Path2D path = new AdobePathReader(data).readPath();
-            assertNotNull(path);
-        });
+        Path2D path = new AdobePathReader(data).readPath();
+        assertNotNull(path);
    }

    @Test
@@ -30,9 +30,9 @@

 package com.twelvemonkeys.imageio.path;

-import org.junit.jupiter.api.Test;
+import org.junit.Test;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 /**
 * AdobePathSegmentTest.
@@ -42,19 +42,20 @@ import static org.junit.jupiter.api.Assertions.*;
 * @version $Id: AdobePathSegmentTest.java,v 1.0 13/12/14 harald.kuhr Exp$
 */
 public class AdobePathSegmentTest {
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateBadSelectorNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(-1, 1));
+        new AdobePathSegment(-1, 1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateBadSelector() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(9, 2));
+        new AdobePathSegment(9, 2);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenLengthRecordNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_LENGTH_RECORD, -1));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_LENGTH_RECORD, -1);
+
    }

    @Test
@@ -71,9 +72,9 @@ public class AdobePathSegmentTest {
        assertEquals(-1, segment.cply, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedLengthRecordNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD, -42));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD, -42);
    }

    @Test
@@ -106,19 +107,19 @@ public class AdobePathSegmentTest {
        assertEquals(1, segment.cply, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenLinkedRecordBad() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 44));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 44);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenLinkedRecordOutOfRangeNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, -16.1, -16.1, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, -16.1, -16.1, 0, 0, 1, 1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenLinkedRecordOutOfRangePositive() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 16.1, 16.1, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 16.1, 16.1, 0, 0, 1, 1);
    }

    @Test
@@ -135,20 +136,20 @@ public class AdobePathSegmentTest {
        assertEquals(1, segment.cply, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenUnlinkedRecordBad() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, 44));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, 44);
    }


-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenUnlinkedRecordOutOfRangeNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, -16.5, 0, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, -16.5, 0, 0, 0, 1, 1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateOpenUnlinkedRecorOutOfRangePositive() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, 0, -17, 0, 0, 16.5, 1));
+        new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED, 0, -17, 0, 0, 16.5, 1);
    }

    /// Closed subpath
@@ -167,19 +168,19 @@ public class AdobePathSegmentTest {
        assertEquals(1, segment.cply, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedLinkedRecordBad() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, 44));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, 44);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedLinkedRecordOutOfRangeNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, -16.5, -.5, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, -16.5, -.5, 0, 0, 1, 1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedLinkedRecordOutOfRangePositive() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, .5, 16.5, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, .5, 16.5, 0, 0, 1, 1);
    }

    @Test
@@ -196,59 +197,59 @@ public class AdobePathSegmentTest {
        assertEquals(1, segment.cply, 0);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedUnlinkedRecordBad() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, 44));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, 44);
    }


-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedUnlinkedRecordOutOfRangeNegative() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, -.5, -16.5, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, -.5, -16.5, 0, 0, 1, 1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateClosedUnlinkedRecordOutOfRangePositive() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, 16.5, .5, 0, 0, 1, 1));
+        new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED, 16.5, .5, 0, 0, 1, 1);
    }

    @Test
    public void testToStringRule() {
        String string = new AdobePathSegment(AdobePathSegment.INITIAL_FILL_RULE_RECORD, 0).toString();
-        assertTrue(string.startsWith("Rule"), string);
-        assertTrue(string.contains("Initial"), string);
-        assertTrue(string.contains("fill"), string);
-        assertTrue(string.contains("rule=0"), string);
+        assertTrue(string, string.startsWith("Rule"));
+        assertTrue(string, string.contains("Initial"));
+        assertTrue(string, string.contains("fill"));
+        assertTrue(string, string.contains("rule=0"));
    }

    @Test
    public void testToStringLength() {
        String string = new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD, 2).toString();
-        assertTrue(string.startsWith("Len"), string);
-        assertTrue(string.contains("Closed"), string);
-        assertTrue(string.contains("subpath"), string);
-        assertTrue(string.contains("length=2"), string);
+        assertTrue(string, string.startsWith("Len"));
+        assertTrue(string, string.contains("Closed"));
+        assertTrue(string, string.contains("subpath"));
+        assertTrue(string, string.contains("length=2"));

        string = new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_LENGTH_RECORD, 42).toString();
-        assertTrue(string.startsWith("Len"), string);
-        assertTrue(string.contains("Open"), string);
-        assertTrue(string.contains("subpath"), string);
-        assertTrue(string.contains("length=42"), string);
+        assertTrue(string, string.startsWith("Len"));
+        assertTrue(string, string.contains("Open"));
+        assertTrue(string, string.contains("subpath"));
+        assertTrue(string, string.contains("length=42"));
    }

    @Test
    public void testToStringOther() {
        String string = new AdobePathSegment(AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED, 0, 0, 1, 1, 0, 0).toString();
-        assertTrue(string.startsWith("Pt"), string);
-        assertTrue(string.contains("Open"), string);
-        assertTrue(string.contains("Bezier"), string);
-        assertTrue(string.contains("linked"), string);
+        assertTrue(string, string.startsWith("Pt"));
+        assertTrue(string, string.contains("Open"));
+        assertTrue(string, string.contains("Bezier"));
+        assertTrue(string, string.contains("linked"));

        string = new AdobePathSegment(AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED, 0, 0, 1, 1, 0, 0).toString();
-        assertTrue(string.startsWith("Pt"), string);
-        assertTrue(string.contains("Closed"), string);
-        assertTrue(string.contains("Bezier"), string);
-        assertTrue(string.contains("linked"), string);
+        assertTrue(string, string.startsWith("Pt"));
+        assertTrue(string, string.contains("Closed"));
+        assertTrue(string, string.contains("Bezier"));
+        assertTrue(string, string.contains("linked"));
    }

    @Test
@@ -31,6 +31,7 @@
 package com.twelvemonkeys.imageio.path;

 import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
+import org.junit.Test;

 import javax.imageio.ImageIO;
 import javax.imageio.stream.ImageInputStream;
@@ -40,11 +41,11 @@ import java.awt.geom.*;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.Arrays;
-import org.junit.jupiter.api.Test;

 import static com.twelvemonkeys.imageio.path.AdobePathSegment.*;
 import static com.twelvemonkeys.imageio.path.PathsTest.assertPathEquals;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;

 /**
 * AdobePathWriterTest.
@@ -55,22 +56,22 @@ import static org.junit.jupiter.api.Assertions.*;
 */
 public class AdobePathWriterTest {

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateWriterNull() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathWriter(null));
+        new AdobePathWriter(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateWriterInvalid() {
-        assertThrows(IllegalArgumentException.class, () -> new AdobePathWriter(new Path2D.Double(Path2D.WIND_NON_ZERO)));
+        new AdobePathWriter(new Path2D.Double(Path2D.WIND_NON_ZERO));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateWriterOutOfBounds() {
        Path2D path = new Path2D.Float(Path2D.WIND_EVEN_ODD);
        path.append(new Ellipse2D.Double(.5, 0.5, 2, 2), false);

-        assertThrows(IllegalArgumentException.class, () -> new AdobePathWriter(path));
+        new AdobePathWriter(path);
    }

    @Test
@@ -92,14 +93,14 @@ public class AdobePathWriterTest {
        new AdobePathWriter(path);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNotClosed() {
        GeneralPath path = new GeneralPath(Path2D.WIND_EVEN_ODD);
        path.moveTo(.5, .5);
        path.lineTo(1, .5);
        path.curveTo(1, 1, 1, 1, .5, 1);

-        assertThrows(IllegalArgumentException.class, () -> new AdobePathWriter(path).writePath());
+        new AdobePathWriter(path).writePath();
    }

    @Test
@@ -33,6 +33,7 @@ package com.twelvemonkeys.imageio.path;
 import com.twelvemonkeys.imageio.stream.ByteArrayImageInputStream;
 import com.twelvemonkeys.imageio.stream.SubImageInputStream;
 import com.twelvemonkeys.imageio.stream.URLImageInputStreamSpi;
+import org.junit.Test;

 import javax.imageio.ImageIO;
 import javax.imageio.spi.IIORegistry;
@@ -47,9 +48,8 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assumptions.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;

 /**
 * PathsTest.
@@ -63,9 +63,9 @@ public class PathsTest {
        IIORegistry.getDefaultInstance().registerServiceProvider(new URLImageInputStreamSpi());
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadPathNull() throws IOException {
-        assertThrows(IllegalArgumentException.class, () -> Paths.readPath(null));
+        Paths.readPath(null);
    }

    @Test
@@ -127,14 +127,14 @@ public class PathsTest {
        assertPathEquals(readExpectedPath("/ser/grape-path.ser"), path);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testApplyClippingPathNullPath() {
-        assertThrows(IllegalArgumentException.class, () -> Paths.applyClippingPath(null, new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY)));
+        Paths.applyClippingPath(null, new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testApplyClippingPathNullSource() {
-        assertThrows(IllegalArgumentException.class, () -> Paths.applyClippingPath(new GeneralPath(), null));
+        Paths.applyClippingPath(new GeneralPath(), null);
    }

    @Test
@@ -165,9 +165,9 @@ public class PathsTest {
    }

    @SuppressWarnings("ConstantConditions")
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testApplyClippingPathNullDestination() {
-        assertThrows(IllegalArgumentException.class, () -> Paths.applyClippingPath(new GeneralPath(), new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY), null));
+        Paths.applyClippingPath(new GeneralPath(), new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY), null);
    }

    @Test
@@ -199,9 +199,9 @@ public class PathsTest {
        // TODO: Mor sophisticated test that tests all pixels outside path...
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadClippedNull() throws IOException {
-        assertThrows(IllegalArgumentException.class, () -> Paths.readClipped(null));
+        Paths.readClipped(null);
    }

    @Test
@@ -243,7 +243,7 @@ public class PathsTest {
    }

    static void assertPathEquals(final Path2D expectedPath, final Path2D actualPath) {
-        assertNotNull(expectedPath, "Expected path is null, check your tests...");
+        assertNotNull("Expected path is null, check your tests...", expectedPath);
        assertNotNull(actualPath);

        PathIterator expectedIterator = expectedPath.getPathIterator(null);
@@ -253,19 +253,19 @@ public class PathsTest {
        float[] actualCoords = new float[6];

        while(!expectedIterator.isDone()) {
-            assertFalse(actualIterator.isDone(), "Less points than expected");
+            assertFalse("Less points than expected", actualIterator.isDone());

            int expectedType = expectedIterator.currentSegment(expectedCoords);
            int actualType = actualIterator.currentSegment(actualCoords);

-            assertEquals( expectedType, actualType, "Unexpected segment type");
-            assertArrayEquals(expectedCoords, actualCoords, 0, "Unexpected coordinates");
+            assertEquals("Unexpected segment type", expectedType, actualType);
+            assertArrayEquals("Unexpected coordinates", expectedCoords, actualCoords, 0);

            actualIterator.next();
            expectedIterator.next();
        }

-        assertTrue( actualIterator.isDone(), "More points than expected");
+        assertTrue("More points than expected", actualIterator.isDone());
    }

    @Test
@@ -4,7 +4,7 @@
    <parent>
        <groupId>com.twelvemonkeys.imageio</groupId>
        <artifactId>imageio</artifactId>
-        <version>3.13.2-SNAPSHOT</version>
+        <version>3.10.2-SNAPSHOT</version>
    </parent>
    <artifactId>imageio-core</artifactId>
    <name>TwelveMonkeys :: ImageIO :: Core</name>
@@ -23,7 +23,6 @@ import static com.twelvemonkeys.lang.Validate.notNull;
 * {@link ImageTypeSpecifier}.
 * Other values or overrides may be specified using the builder.
 *
- * @see <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/imageio/metadata/doc-files/standard_metadata.html">Standard (Plug-in Neutral) Metadata Format Specification</a>
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 */
 public class StandardImageMetadataSupport extends AbstractMetadata {
@@ -80,11 +79,11 @@ public class StandardImageMetadataSupport extends AbstractMetadata {
        textEntries = builder.textEntries;
    }

-    protected static Builder builder(ImageTypeSpecifier type) {
+    public static Builder builder(ImageTypeSpecifier type) {
        return new Builder(type);
    }

-    protected static class Builder {
+    public static class Builder {
        private final ImageTypeSpecifier type;
        private ColorSpaceType colorSpaceType;
        private boolean blackIsZero = true;
@@ -37,14 +37,14 @@ import java.io.IOException;
 import static com.twelvemonkeys.lang.Validate.notNull;

 /**
- * ImageOutputStream that writes through a delegate, but keeps local position and bit offset.
+ * ImageInputStream that writes through a delegate, but keeps local position and bit offset.
 * Note: Flushing or closing this stream will *not* have an effect on the delegate.
 *
 * @author <a href="mailto:harald.kuhr@gmail.com">Harald Kuhr</a>
 * @author last modified by $Author: harald.kuhr$
 * @version $Id: SubImageOutputStream.java,v 1.0 30/03/15 harald.kuhr Exp$
 */
-public final class SubImageOutputStream extends ImageOutputStreamImpl {
+public class SubImageOutputStream extends ImageOutputStreamImpl {
    private final ImageOutputStream stream;
    private final long startPos;

@@ -35,21 +35,17 @@ import com.twelvemonkeys.lang.Validate;

 import javax.imageio.IIOParam;
 import javax.imageio.ImageIO;
-import javax.imageio.ImageReadParam;
-import javax.imageio.ImageWriteParam;
 import javax.imageio.spi.IIOServiceProvider;
 import javax.imageio.spi.ServiceRegistry;
 import javax.imageio.stream.ImageInputStream;
 import javax.imageio.stream.ImageOutputStream;
 import java.awt.*;
-import java.awt.image.*;
+import java.awt.image.BufferedImage;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.Arrays;
 import java.util.Iterator;
-import java.util.Objects;
 import java.util.SortedSet;
 import java.util.TreeSet;

@@ -72,7 +68,7 @@ public final class IIOUtil {
     */
    public static InputStream createStreamAdapter(final ImageInputStream pStream) {
        // TODO: Include stream start pos?
-        // TODO: Skip buffering for known in-memory implementations? pStream.isCachedMemory
+        // TODO: Skip buffering for known in-memory implementations?
        return new BufferedInputStream(new IIOInputStreamAdapter(pStream));
    }

@@ -86,7 +82,7 @@ public final class IIOUtil {
     */
    public static InputStream createStreamAdapter(final ImageInputStream pStream, final long pLength) {
        // TODO: Include stream start pos?
-        // TODO: Skip buffering for known in-memory implementations? pStream.isCachedMemory
+        // TODO: Skip buffering for known in-memory implementations?
        return new BufferedInputStream(new IIOInputStreamAdapter(pStream, pLength));
    }

@@ -236,10 +232,6 @@ public final class IIOUtil {
                                    int samplesPerPixel, int bitsPerSample, int samplePeriod) {
        // Period == 1 is a no-op...
        if (samplePeriod == 1) {
-            if (srcRow != destRow) {
-                System.arraycopy(srcRow, srcPos, destRow, destPos, srcWidth);
-            }
-
            return;
        }

@@ -283,10 +275,6 @@ public final class IIOUtil {
                                    int samplesPerPixel, int bitsPerSample, int samplePeriod) {
        // Period == 1 is a no-op...
        if (samplePeriod == 1) {
-            if (srcRow != destRow) {
-                System.arraycopy(srcRow, srcPos, destRow, destPos, srcWidth);
-            }
-
            return;
        }

@@ -295,7 +283,7 @@ public final class IIOUtil {
                "bitsPerSample must be > 0 and <= 16 and a power of 2");
        Validate.isTrue(samplesPerPixel > 0, "samplesPerPixel must be > 0");
        Validate.isTrue(samplesPerPixel * bitsPerSample <= 16 || samplesPerPixel * bitsPerSample % 16 == 0,
-                "samplesPerPixel * bitsPerSample must be < 16 or a multiple of 16");
+                "samplesPerPixel * bitsPerSample must be < 16 or a multiple of 16 ");

        int pixelStride = bitsPerSample * samplesPerPixel / 16;
        for (int x = 0; x < srcWidth * pixelStride; x += samplePeriod * pixelStride) {
@@ -309,10 +297,6 @@ public final class IIOUtil {
                                    int samplesPerPixel, int bitsPerSample, int samplePeriod) {
        // Period == 1 is a no-op...
        if (samplePeriod == 1) {
-            if (srcRow != destRow) {
-                System.arraycopy(srcRow, srcPos, destRow, destPos, srcWidth);
-            }
-
            return;
        }

@@ -321,7 +305,7 @@ public final class IIOUtil {
                "bitsPerSample must be > 0 and <= 32 and a power of 2");
        Validate.isTrue(samplesPerPixel > 0, "samplesPerPixel must be > 0");
        Validate.isTrue(samplesPerPixel * bitsPerSample <= 32 || samplesPerPixel * bitsPerSample % 32 == 0,
-                "samplesPerPixel * bitsPerSample must be < 32 or a multiple of 32");
+                "samplesPerPixel * bitsPerSample must be < 32 or a multiple of 32 ");

        int pixelStride = bitsPerSample * samplesPerPixel / 32;
        for (int x = 0; x < srcWidth * pixelStride; x += samplePeriod * pixelStride) {
@@ -338,7 +322,7 @@ public final class IIOUtil {
                "bitsPerSample must be > 0 and <= 32 and a power of 2");
        Validate.isTrue(samplesPerPixel > 0, "samplesPerPixel must be > 0");
        Validate.isTrue(samplesPerPixel * bitsPerSample <= 32 || samplesPerPixel * bitsPerSample % 32 == 0,
-                "samplesPerPixel * bitsPerSample must be < 32 or a multiple of 32");
+                "samplesPerPixel * bitsPerSample must be < 32 or a multiple of 32 ");

        int pixelStride = bitsPerSample * samplesPerPixel / 32;
        for (int x = 0; x < srcWidth * pixelStride; x += samplePeriod * pixelStride) {
@@ -346,132 +330,4 @@ public final class IIOUtil {
            System.arraycopy(srcRow, srcPos + x, destRow, destPos + x / samplePeriod, pixelStride);
        }
    }
-
-    public static void subsampleRow(double[] srcRow, int srcPos, int srcWidth,
-                                    double[] destRow, int destPos,
-                                    int samplesPerPixel, int bitsPerSample, int samplePeriod) {
-        Validate.isTrue(samplePeriod > 1, "samplePeriod must be > 1"); // Period == 1 could be a no-op...
-        Validate.isTrue(bitsPerSample > 0 && bitsPerSample <= 64 && (bitsPerSample == 1 || bitsPerSample % 2 == 0),
-                "bitsPerSample must be > 0 and <= 64 and a power of 2");
-        Validate.isTrue(samplesPerPixel > 0, "samplesPerPixel must be > 0");
-        Validate.isTrue(samplesPerPixel * bitsPerSample <= 64 || samplesPerPixel * bitsPerSample % 64 == 0,
-                "samplesPerPixel * bitsPerSample must be < 64 or a multiple of 64");
-
-        int pixelStride = bitsPerSample * samplesPerPixel / 64;
-        for (int x = 0; x < srcWidth * pixelStride; x += samplePeriod * pixelStride) {
-            // System.arraycopy should be intrinsic, but consider using direct array access for pixelStride == 1
-            System.arraycopy(srcRow, srcPos + x, destRow, destPos + x / samplePeriod, pixelStride);
-        }
-    }
-
-    /**
-     * Copies all the standard param values from source to destination.
-     * <p>
-     * Typical use (in some imaginary {@code FooImageWriter} class):
-     * </p>
-     *
-     * <pre>
-     * ImageWriteParam param = ...
-     * FooImageWriteparam fooParam = param instanceof FooImageWriteParam
-     *      ? (FooImageWriteParam) param
-     *      : copyStandardParams(param, getDefaultWriteParam());
-     * </pre>
-     *
-     * May also be useful for {@code ImageReader}s that delegate reading to other plugins
-     * (like a TIFF plugin delegating JPEG format decoding to a {@code JPEGImageReader}).
-     *
-     * @param source the source parameter, may be {@code null}
-     * @param destination the destination parameter
-     * @return destination
-     *
-     * @param <T> the plugin specific subclass of {@code IIOParam}
-     *
-     * @throws NullPointerException if destination is {@code null}
-     */
-    public static <T extends IIOParam> T copyStandardParams(IIOParam source, T destination) {
-        Objects.requireNonNull(destination);
-        Validate.isTrue(source != destination, "source must be different from destination");
-
-        if (source != null) {
-            copyIIOParams(source, destination);
-
-            // TODO: API & usage... Is it ever useful to copy from a read to a write param or vice versa?
-            //  If not, maybe throw an IllegalArgumentException instead
-
-            if (source instanceof ImageReadParam && destination instanceof ImageReadParam) {
-                copyImageReadParams((ImageReadParam) source, (ImageReadParam) destination);
-            }
-
-            if (source instanceof ImageWriteParam && destination instanceof ImageWriteParam) {
-                copyImageWriteParams((ImageWriteParam) source, (ImageWriteParam) destination);
-            }
-        }
-
-        return destination;
-    }
-
-    private static void copyImageWriteParams(ImageWriteParam source, ImageWriteParam destination) {
-        // TODO: Usage... It's very unlikely that compression settings of one plugin is compatible with another...
-        //  Is the the below useful?
-        //  Also, is it okay to just silently ignore settings from one format that isn't compatible with another?
-
-        // Quirky API, we can't query for compression mode, unless source.canWriteCompressed is true...
-        if (source.canWriteCompressed() && destination.canWriteCompressed()) {
-            int compressionMode = source.getCompressionMode();
-            destination.setCompressionMode(compressionMode);
-
-            if (compressionMode == ImageWriteParam.MODE_EXPLICIT
-                && source.getCompressionType() != null
-                && Arrays.asList(destination.getCompressionTypes()).contains(source.getCompressionType())) {
-                    destination.setCompressionType(source.getCompressionType());
-                    destination.setCompressionQuality(source.getCompressionQuality());
-            }
-        }
-
-        if (source.canWriteProgressive() && destination.canWriteProgressive()) {
-            destination.setProgressiveMode(source.getProgressiveMode());
-        }
-
-        if (source.canWriteTiles() && destination.canWriteTiles()) {
-            int tilingMode = source.getTilingMode();
-            destination.setTilingMode(tilingMode);
-
-            if (tilingMode == ImageWriteParam.MODE_EXPLICIT) {
-                // TODO: What if source can offset (and has offsets) and dest can't? Is it ok to just ignore the setting?
-                boolean canWriteOffsetTiles = source.canOffsetTiles() && destination.canOffsetTiles();
-
-                destination.setTiling(
-                    source.getTileWidth(), source.getTileHeight(),
-                    canWriteOffsetTiles ? source.getTileGridXOffset() : 0,
-                    canWriteOffsetTiles ? source.getTileGridYOffset() : 0
-                );
-            }
-        }
-    }
-
-    private static void copyImageReadParams(ImageReadParam source, ImageReadParam destination) {
-        destination.setDestination(source.getDestination());
-        destination.setDestinationBands(source.getDestinationBands());
-
-        if (destination.canSetSourceRenderSize()) {
-            destination.setSourceRenderSize(source.getSourceRenderSize());
-        }
-
-        destination.setSourceProgressivePasses(
-            source.getSourceMinProgressivePass(),
-            source.getSourceMaxProgressivePass()
-        );
-    }
-
-    private static void copyIIOParams(IIOParam source, IIOParam destination) {
-        destination.setController(source.getController());
-        destination.setSourceSubsampling(
-            source.getSourceXSubsampling(), source.getSourceYSubsampling(),
-            source.getSubsamplingXOffset(), source.getSubsamplingYOffset()
-        );
-        destination.setSourceRegion(source.getSourceRegion());
-        destination.setSourceBands(source.getSourceBands());
-        destination.setDestinationOffset(source.getDestinationOffset());
-        destination.setDestinationType(source.getDestinationType());
-    }
 }
@@ -30,9 +30,11 @@

 package com.twelvemonkeys.imageio;

-
 import static java.util.Collections.singleton;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 import java.awt.*;
 import java.awt.color.ColorSpace;
 import java.awt.image.BufferedImage;
@@ -46,7 +48,7 @@ import javax.imageio.IIOException;
 import javax.imageio.ImageReadParam;
 import javax.imageio.ImageTypeSpecifier;

-import org.junit.jupiter.api.Test;
+import org.junit.Test;

 /**
 * ImageReaderBaseTest
@@ -62,36 +64,36 @@ public class ImageReaderBaseTest {
            ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_ARGB)
    );

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationZeroWidth() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, TYPES.iterator(), 0, 42));
+        ImageReaderBase.getDestination(null, TYPES.iterator(), 0, 42);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationNegativeWidth() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, TYPES.iterator(), -1, 42));
+        ImageReaderBase.getDestination(null, TYPES.iterator(), -1, 42);

    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationZeroHeight() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, TYPES.iterator(), 42, 0));
+        ImageReaderBase.getDestination(null, TYPES.iterator(), 42, 0);

    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationNegativeHeight() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, TYPES.iterator(), 42, -1));
+        ImageReaderBase.getDestination(null, TYPES.iterator(), 42, -1);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationNullTypes() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, null, 42, 42));
+        ImageReaderBase.getDestination(null, null, 42, 42);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testGetDestinationNoTypes() throws IIOException {
-        assertThrows(IllegalArgumentException.class, () -> ImageReaderBase.getDestination(null, Collections.<ImageTypeSpecifier>emptyList().iterator(), 42, 42));
+        ImageReaderBase.getDestination(null, Collections.<ImageTypeSpecifier>emptyList().iterator(), 42, 42);
    }

    @Test
@@ -160,11 +162,11 @@ public class ImageReaderBaseTest {
        assertEquals(1, destination.getHeight());
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationParamIllegalDestination() throws IIOException {
        ImageReadParam param = new ImageReadParam();
        param.setDestination(new BufferedImage(21, 1, BufferedImage.TYPE_USHORT_565_RGB));
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(param, TYPES.iterator(), 42, 1));
+        ImageReaderBase.getDestination(param, TYPES.iterator(), 42, 1);
    }

    @Test
@@ -189,18 +191,18 @@ public class ImageReaderBaseTest {
        assertEquals(7, destination.getHeight());
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationParamIllegalDestinationType() throws IIOException {
        ImageReadParam param = new ImageReadParam();
        param.setDestinationType(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY));
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(param, TYPES.iterator(), 6, 7));
+        ImageReaderBase.getDestination(param, TYPES.iterator(), 6, 7);
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationParamIllegalDestinationTypeAlt() throws IIOException {
        ImageReadParam param = new ImageReadParam();
        param.setDestinationType(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_BGR));
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(param, TYPES.iterator(), 6, 7));
+        ImageReaderBase.getDestination(param, TYPES.iterator(), 6, 7);
    }

    @Test
@@ -213,22 +215,22 @@ public class ImageReaderBaseTest {
        assertEquals(TYPES.get(0).getBufferedImageType(), destination.getType());
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationParamDestinationExceedsIntegerMax() throws IIOException {
        ImageReadParam param = new ImageReadParam();
        param.setSourceRegion(new Rectangle(3 * Short.MAX_VALUE, 2 * Short.MAX_VALUE)); // 6 442 057 734 pixels
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(param, TYPES.iterator(), 6 * Short.MAX_VALUE, 4 * Short.MAX_VALUE)); // 25 768 230 936 pixels
+        ImageReaderBase.getDestination(param, TYPES.iterator(), 6 * Short.MAX_VALUE, 4 * Short.MAX_VALUE); // 25 768 230 936 pixels
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationDimensionExceedsIntegerMax() throws IIOException {
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(null, TYPES.iterator(), 3 * Short.MAX_VALUE, 2 * Short.MAX_VALUE)); // 6 442 057 734 pixels
+        ImageReaderBase.getDestination(null, TYPES.iterator(), 3 * Short.MAX_VALUE, 2 * Short.MAX_VALUE); // 6 442 057 734 pixels
    }

-    @Test
+    @Test(expected = IIOException.class)
    public void testGetDestinationStorageExceedsIntegerMax() throws IIOException {
        Set<ImageTypeSpecifier> byteTypes = singleton(ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_3BYTE_BGR));
-        assertThrows(IIOException.class, () -> ImageReaderBase.getDestination(null, byteTypes.iterator(), Short.MAX_VALUE,  Short.MAX_VALUE)); // 1 073 676 289 pixels
+        ImageReaderBase.getDestination(null, byteTypes.iterator(), Short.MAX_VALUE,  Short.MAX_VALUE); // 1 073 676 289 pixels
        // => 3 221 028 867 bytes needed in continuous array, not possible
    }

@@ -7,9 +7,9 @@ import com.twelvemonkeys.imageio.StandardImageMetadataSupport.SubimageInterpreta
 import com.twelvemonkeys.imageio.StandardImageMetadataSupport.TextEntry;
 import com.twelvemonkeys.imageio.util.ImageTypeSpecifiers;

+import org.junit.Test;
 import org.w3c.dom.NodeList;

-import javax.imageio.IIOException;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.metadata.IIOMetadataNode;
 import java.awt.image.*;
@@ -23,23 +23,22 @@ import java.util.Map;
 import java.util.Map.Entry;

 import static com.twelvemonkeys.imageio.StandardImageMetadataSupport.builder;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 public class StandardImageMetadataSupportTest {
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void createNullBuilder() {
-        assertThrows(IllegalArgumentException.class, () -> new StandardImageMetadataSupport(null));
+        new StandardImageMetadataSupport(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void createNullType() {
-        assertThrows(IllegalArgumentException.class, () -> new StandardImageMetadataSupport(builder(null)));
+        new StandardImageMetadataSupport(builder(null));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void builderNullType() {
-        assertThrows(IllegalArgumentException.class, () -> builder(null).build());
+        builder(null).build();
    }

    @Test
@@ -90,10 +89,10 @@ public class StandardImageMetadataSupportTest {
        assertEquals("TRUE", compressionLossless.getAttribute("value"));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void withCompressionLossyIllegal() {
-        assertThrows(IllegalArgumentException.class, () -> builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
-                .withCompressionLossless(false));
+        builder(ImageTypeSpecifiers.createFromBufferedImageType(BufferedImage.TYPE_BYTE_GRAY))
+                .withCompressionLossless(false);
    }

    @Test
@@ -31,9 +31,9 @@
 package com.twelvemonkeys.imageio.color;

 import com.twelvemonkeys.imageio.color.CIELabColorConverter.Illuminant;
+import org.junit.Test;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.assertArrayEquals;

 /**
 * CIELabColorConverterTest.
@@ -43,9 +43,9 @@ import static org.junit.jupiter.api.Assertions.*;
 * @version $Id: CIELabColorConverterTest.java,v 1.0 22/10/15 harald.kuhr Exp$
 */
 public class CIELabColorConverterTest {
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testNoIllumninant() {
-        assertThrows(IllegalArgumentException.class, () -> new CIELabColorConverter(null));
+        new CIELabColorConverter(null);
    }

    @Test
@@ -1,5 +1,7 @@
 package com.twelvemonkeys.imageio.color;

+import org.junit.Test;
+
 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 import java.awt.color.ICC_Profile;
@@ -7,8 +9,7 @@ import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.Assert.*;

 public class ColorProfilesTest {
    @Test
@@ -52,9 +53,9 @@ public class ColorProfilesTest {
        assertFalse(ColorProfiles.isCS_sRGB(ICC_Profile.getInstance(ColorSpace.CS_PYCC)));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testIsCS_sRGBNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.isCS_sRGB(null));
+        ColorProfiles.isCS_sRGB(null);
    }

    @Test
@@ -70,29 +71,29 @@ public class ColorProfilesTest {
        assertFalse(ColorProfiles.isCS_GRAY(ICC_Profile.getInstance(ColorSpace.CS_PYCC)));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testIsCS_GRAYNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.isCS_GRAY(null));
+        ColorProfiles.isCS_GRAY(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfile(null));
+        ColorProfiles.createProfile(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileNull() throws IOException {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfile(null));
+        ColorProfiles.readProfile(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileRawNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfileRaw(null));
+        ColorProfiles.createProfileRaw(null);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileRawNull() throws IOException {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfileRaw(null));
+        ColorProfiles.readProfileRaw(null);
    }

    @Test
@@ -109,74 +110,74 @@ public class ColorProfilesTest {
        assertArrayEquals(data, profileRaw.getData());
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileRawBadData() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfileRaw(new byte[5]));
+        ColorProfiles.createProfileRaw(new byte[5]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileRawBadData() throws IOException {
        // NOTE: The array here is larger, as there's a bug in OpenJDK 15 & 16, that throws
        // ArrayIndexOutOfBoundsException if the stream is shorter than the profile signature...
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfileRaw(new ByteArrayInputStream(new byte[40])));
+        ColorProfiles.readProfileRaw(new ByteArrayInputStream(new byte[40]));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileBadData() {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfile(new byte[5]));
+        ColorProfiles.createProfile(new byte[5]);
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileBadData() throws IOException {
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfile(new ByteArrayInputStream(new byte[5])));
+        ColorProfiles.readProfile(new ByteArrayInputStream(new byte[5]));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileRawTruncated() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfileRaw(Arrays.copyOf(data, 200)));
+        ColorProfiles.createProfileRaw(Arrays.copyOf(data, 200));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileRawTruncated() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfileRaw(new ByteArrayInputStream(data, 0, 200)));
+        ColorProfiles.readProfileRaw(new ByteArrayInputStream(data, 0, 200));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileTruncated() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfile(Arrays.copyOf(data, 200)));
+        ColorProfiles.createProfile(Arrays.copyOf(data, 200));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileTruncated() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfile(new ByteArrayInputStream(data, 0, 200)));
+        ColorProfiles.readProfile(new ByteArrayInputStream(data, 0, 200));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileRawTruncatedHeader() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfileRaw(Arrays.copyOf(data, 125)));
+        ColorProfiles.createProfileRaw(Arrays.copyOf(data, 125));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileRawTruncatedHeader() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfileRaw(new ByteArrayInputStream(data, 0, 125)));
+        ColorProfiles.readProfileRaw(new ByteArrayInputStream(data, 0, 125));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateProfileTruncatedHeader() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.createProfile(Arrays.copyOf(data, 125)));
+        ColorProfiles.createProfile(Arrays.copyOf(data, 125));
    }

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testReadProfileTruncatedHeader() throws IOException {
        byte[] data = ICC_Profile.getInstance(getClass().getResourceAsStream("/profiles/adobe_rgb_1998.icc")).getData();
-        assertThrows(IllegalArgumentException.class, () -> ColorProfiles.readProfile(new ByteArrayInputStream(data, 0, 125)));
+        ColorProfiles.readProfile(new ByteArrayInputStream(data, 0, 125));
    }

    @Test
@@ -30,16 +30,15 @@

 package com.twelvemonkeys.imageio.color;

-
+import org.junit.Test;

 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 import java.awt.color.ICC_Profile;
 import java.io.IOException;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeTrue;

 /**
 * ColorSpacesTest
@@ -155,9 +154,9 @@ public class ColorSpacesTest {
    }

    @SuppressWarnings("deprecation")
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testIsCS_sRGBNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorSpaces.isCS_sRGB(null));
+        ColorSpaces.isCS_sRGB(null);
    }

    @SuppressWarnings("deprecation")
@@ -176,9 +175,9 @@ public class ColorSpacesTest {
    }

    @SuppressWarnings("deprecation")
-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testIsCS_GRAYNull() {
-        assertThrows(IllegalArgumentException.class, () -> ColorSpaces.isCS_GRAY(null));
+        ColorSpaces.isCS_GRAY(null);
    }

    @Test
@@ -31,20 +31,21 @@
 package com.twelvemonkeys.imageio.color;

 import org.hamcrest.CoreMatchers;
+import org.junit.Test;

 import java.awt.image.*;
-import org.junit.jupiter.api.Test;

 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;

 public class DiscreteAlphaIndexColorModelTest {

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testCreateNull() {
-        assertThrows(IllegalArgumentException.class, () -> new DiscreteAlphaIndexColorModel(null));
+        new DiscreteAlphaIndexColorModel(null);
    }

    @Test
@@ -201,7 +202,7 @@ public class DiscreteAlphaIndexColorModelTest {
        assertEquals(2, raster.getHeight());

        assertTrue(colorModel.isCompatibleRaster(raster));
-        assertThat(raster, instanceOf(WritableRaster.class));  // Checks if raster is an instance of WritableRaster or its subclass
+        assertThat(raster, CoreMatchers.is(WritableRaster.class)); // Specific subclasses are in sun.awt package
        assertThat(raster.getTransferType(), CoreMatchers.equalTo(DataBuffer.TYPE_BYTE));
    }

@@ -30,6 +30,8 @@

 package com.twelvemonkeys.imageio.color;

+import org.junit.Test;
+
 import java.awt.color.ColorSpace;
 import java.awt.color.ICC_ColorSpace;
 import java.awt.color.ICC_Profile;
@@ -37,18 +39,16 @@ import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.Arrays;

-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.*;
-
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assume.assumeFalse;
 import static org.mockito.Mockito.*;

 public class KCMSSanitizerStrategyTest {
    private static final byte[] XYZ = new byte[] {'X', 'Y', 'Z', ' '};

-    @Test
+    @Test(expected = IllegalArgumentException.class)
    public void testFixProfileNullProfile() throws Exception {
-        assertThrows(IllegalArgumentException.class, () -> new KCMSSanitizerStrategy().fixProfile(null));
+        new KCMSSanitizerStrategy().fixProfile(null);
    }

    @Test
@@ -77,7 +77,7 @@ public class KCMSSanitizerStrategyTest {
        try {
            Method isSealed = Class.class.getMethod("isSealed");
            Boolean result = (Boolean) isSealed.invoke(ICC_Profile.class);
-            assumeFalse(result, "Can't mock ICC_Profile, class is sealed (as of JDK 19).");
+            assumeFalse("Can't mock ICC_Profile, class is sealed (as of JDK 19).", result);
        }
        catch (ReflectiveOperationException ignore) {
            // We can't have sealed classes if we don't have the isSealed method...
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Harald Kuhr	666e0ef94a	[maven-release-plugin] prepare for next development iteration	2023-11-07 20:24:45 +01:00
Harald Kuhr	b58c4ba5dd	[maven-release-plugin] prepare release twelvemonkeys-3.10.1	2023-11-07 20:24:40 +01:00
Harald Kuhr	6328862e4f	Set versions to 3.10.1-SNAPSHOT	2023-11-07 20:17:30 +01:00