From b3e46a18908e2f0eaafafa223e7485cab047af50 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Tue, 9 Jun 2026 14:45:38 +0100
Subject: [PATCH 01/36] fix DocumentName issues

---
 .../java/org/apache/rat/document/DocumentName.java     | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index c6cc55f22..ca6736599 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -625,6 +625,16 @@ private int compareData(final DocumentName.FSInfoData otherData) {
             return result;
         }
 
+        /**
+         * Creates a path separated by the directory separator.
+         * Starting with an empty string will cause the directory separateor to appear at the beginning.
+         * @param segments the segments that make up the path.
+         * @return the path string.
+         */
+        public String mkPath(final String... segments) {
+            return String.join(dirSeparator(), segments);
+        }
+
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);

From 51064da30a508a156958ecca27b84838c48cf117 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Tue, 16 Jun 2026 16:00:39 +0100
Subject: [PATCH 02/36] checkpoint

---
 .../ReportTest/RAT_406/src/dojo/dojo2.jav     |  7 +++
 .../AbstractConfigurationOptionsProvider.java | 47 +++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav

diff --git a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
new file mode 100644
index 000000000..f832e15d6
--- /dev/null
+++ b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
@@ -0,0 +1,7 @@
+/**
+ * DOJO flag
+ http://dojotoolkit.org/community/licensing.shtml
+ */
+interface dojo2 {
+
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index 5d34d80a8..0ed4694c1 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -552,6 +552,53 @@ Licensed to the Apache Software Foundation (ASF) under one or more
         return xmlPath.toString();
     }
 
+    private String writeConfigXML(String name) {
+        String licenseText = """
+                Licensed to the Apache Software Foundation (ASF) under one or more
+                       contributor license agreements.  See the NOTICE file distributed with
+                       this work for additional information regarding copyright ownership.
+                               The ASF licenses this file to You under the Apache License, Version 2.0
+                       (the "License"); you may not use this file except in compliance with
+                       the License.  You may obtain a copy of the License at
+                
+                       http://www.apache.org/licenses/LICENSE-2.0
+                
+                       Unless required by applicable law or agreed to in writing, software
+                       distributed under the License is distributed on an "AS IS" BASIS,
+                               WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+                               See the License for the specific language governing permissions and
+                       limitations under the License.""";
+        String capName = WordUtils.capitalize(name);
+        String upperName = name.toUpperCase(Locale.ROOT);
+
+        Path xmlPath = OptionCollectionTest.getTestPath().resolve(".rat/" + capName + ".xml");
+        File f = xmlPath.toFile();
+        try {
+            FileUtils.forceMkdir(f.getParentFile());
+            try (FileWriter writer = new FileWriter(f);
+                 XmlWriter xmlWriter = new XmlWriter(writer)) {
+
+                xmlWriter.startDocument()
+                        .comment(licenseText)
+                        .openElement("rat-config")
+                        .openElement("families")
+                        .openElement("family")
+                        .attribute("id", upperName)
+                        .attribute("name", "from " + capName + ".xml")
+                        .closeElement("families")
+                        .openElement("licenses")
+                        .openElement("license")
+                        .attribute("family", upperName)
+                        .openElement("text")
+                        .content(name)
+                        .closeElement("rat-config");
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return xmlPath.toString();
+    }
+
     private void configTest(final Option option) {
         String[] args = {writeConfigXML("one"), writeConfigXML("two")};
         Pair<Option, String[]> arg1 = ImmutablePair.of(option, args);

From 805b4230a4fd9b8530d253841544afe569bf8150 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Thu, 18 Jun 2026 13:49:48 +0100
Subject: [PATCH 03/36] Fixed several parsing errors in DocumentName.Builder
 Add testing Expanded testing to include multiple file system types Fix
 recursion issue in DocumentName equals and compareTo Additional migration to
 assertj Changed File options to return DocumentName instances. Cleaned up
 Sonar review issues

---
 .../ReportTest/RAT_406/src/dojo/dojo2.jav     |  7 ----
 .../org/apache/rat/document/DocumentName.java | 37 +++++++++++++++++++
 .../rat/commandline/FileConverterTest.java    |  1 +
 .../AbstractConfigurationOptionsProvider.java |  2 +-
 4 files changed, 39 insertions(+), 8 deletions(-)
 delete mode 100644 apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav

diff --git a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
deleted file mode 100644
index f832e15d6..000000000
--- a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * DOJO flag
- http://dojotoolkit.org/community/licensing.shtml
- */
-interface dojo2 {
-
-}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index ca6736599..c86106920 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -635,6 +635,43 @@ public String mkPath(final String... segments) {
             return String.join(dirSeparator(), segments);
         }
 
+        /**
+         * Determines if the candidate string starts with a root or directory separator as defined in this
+         * FSInfo.
+         * @param candidate the candidate string to test.
+         * @return {@code true} if the candidate starts with a root or a directory separator.
+         */
+        public boolean startsWithRootOrSeparator(final String candidate) {
+            if (candidate == null) {
+                return false;
+            }
+            String target = candidate.trim();
+            if (StringUtils.isBlank(target)) {
+                return false;
+            }
+            for (String root : roots()) {
+                if (target.startsWith(root)) {
+                    return true;
+                }
+            }
+            return target.startsWith(dirSeparator());
+        }
+
+        private int compareData(final DocumentName.FSInfoData otherData) {
+            int result = Boolean.compare(this.data.isCaseSensitive, otherData.isCaseSensitive);
+            if (result == 0) {
+                result = this.data.separator.compareTo(otherData.separator);
+                if (result == 0) {
+                    if (new HashSet<>(this.data.roots).containsAll(otherData.roots)) {
+                        result = new HashSet<>(otherData.roots).containsAll(this.data.roots) ? 0 : 1;
+                    } else {
+                        result = -1;
+                    }
+                }
+            }
+            return result;
+        }
+
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
index f1922638a..8213bbdb5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
@@ -78,6 +78,7 @@ static List<Arguments> applyTestData() {
                 String root = fsInfo.roots()[1];
                 lst.add(Arguments.of(fsInfo, root + "foo/bar.txt", underTest, root + String.join(fsInfo.dirSeparator(), "foo", "bar.txt")));
                 lst.add(Arguments.of(fsInfo, root + "foo\\bar.txt", underTest, root + String.join(fsInfo.dirSeparator(), "foo", "bar.txt")));
+
             }
         }
         return lst;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index 0ed4694c1..df5888a88 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -571,7 +571,7 @@ Licensed to the Apache Software Foundation (ASF) under one or more
         String capName = WordUtils.capitalize(name);
         String upperName = name.toUpperCase(Locale.ROOT);
 
-        Path xmlPath = OptionCollectionTest.getTestPath().resolve(".rat/" + capName + ".xml");
+        Path xmlPath = this.baseDir.toPath().resolve(".rat/" + capName + ".xml");
         File f = xmlPath.toFile();
         try {
             FileUtils.forceMkdir(f.getParentFile());

From 57124fc54470fafa21299884598a9b7392552581 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 10 May 2026 10:23:40 +0100
Subject: [PATCH 04/36] initial changes

---
 .../java/org/apache/rat/utils}/FileUtils.java |  23 +-
 .../apache/rat/ReporterOptionsProvider.java   |   2 +-
 .../org/apache/rat/ReporterOptionsTest.java   |   2 +-
 .../rat/test/AbstractOptionsProvider.java     |   2 +-
 .../data/AbstractTestDataProvider.java        | 200 +++++++++++++++
 .../apache/rat/testhelpers/data/TestData.java | 242 ++++++++++++++++++
 .../rat/testhelpers/data/ValidatorData.java   | 113 ++++++++
 7 files changed, 571 insertions(+), 13 deletions(-)
 rename apache-rat-core/src/{test/java/org/apache/rat/testhelpers => main/java/org/apache/rat/utils}/FileUtils.java (81%)
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java

diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
similarity index 81%
rename from apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java
rename to apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
index 5681e7972..50da3eccd 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/FileUtils.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations      *
  * under the License.                                           *
  */
-package org.apache.rat.testhelpers;
+package org.apache.rat.utils;
 
 import java.io.File;
 import java.io.FileWriter;
@@ -25,15 +25,17 @@
 import java.util.Arrays;
 import java.util.Collections;
 
-import static org.assertj.core.api.Fail.fail;
 
-public class FileUtils {
+public final class FileUtils {
+    private FileUtils() {
+        // do not instantiate
+    }
 
     /**
      * Creates a directory if it does not exist.
      * @param dir the directory to make.
      */
-    public static void mkDir(File dir) {
+    public static void mkDir(final File dir) {
         boolean ignored = dir.mkdirs();
     }
 
@@ -41,7 +43,7 @@ public static void mkDir(File dir) {
      * Deletes a file if it exists.
      * @param file the file to delete.
      */
-    public static void delete(File file) {
+    public static void delete(final File file) {
         if (file.exists()) {
             if (file.isDirectory()) {
                 try {
@@ -62,15 +64,16 @@ public static void delete(File file) {
      * @param lines the lines to write into the file.
      * @return the new File.
      */
-    static public File writeFile(File dir, final String name, final Iterable<String> lines) {
+    public static  File writeFile(final File dir, final String name, final Iterable<String> lines) {
         if (dir == null) {
-            fail("base directory not specified");
+            throw new IllegalArgumentException("base directory not specified");
         }
+        mkDir(dir);
         File file = new File(dir, name);
         try (PrintWriter writer = new PrintWriter(new FileWriter(file))) {
             lines.forEach(writer::println);
         } catch (IOException e) {
-            fail(e.getMessage());
+            throw new RuntimeException(e.getMessage(), e);
         }
         return file;
     }
@@ -82,7 +85,7 @@ static public File writeFile(File dir, final String name, final Iterable<String>
      * @param lines the lines to write into the file.
      * @return the new File.
      */
-    static public File writeFile(File dir, final String name, final String... lines) {
+    public static File writeFile(final File dir, final String name, final String... lines) {
         return writeFile(dir, name, Arrays.asList(lines));
     }
 
@@ -92,7 +95,7 @@ static public File writeFile(File dir, final String name, final String... lines)
      * @param name the name of the file.
      * @return the new file.
      */
-    public static File writeFile(File dir, String name) {
+    public static File writeFile(final File dir, final String name) {
         return writeFile(dir, name, Collections.singletonList(name));
     }
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 0ef6f019c..b6167cbf7 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -54,7 +54,7 @@
 import org.apache.rat.test.AbstractOptionsProvider;
 import org.apache.rat.test.utils.OptionFormatter;
 import org.apache.rat.test.utils.Resources;
-import org.apache.rat.testhelpers.FileUtils;
+import org.apache.rat.utils.FileUtils;
 import org.apache.rat.testhelpers.TestingLog;
 import org.apache.rat.testhelpers.TextUtils;
 import org.apache.rat.testhelpers.XmlUtils;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
index ccb82f3c6..2694b4c91 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
@@ -27,7 +27,7 @@
 import org.apache.rat.api.RatException;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.test.AbstractConfigurationOptionsProvider;
-import org.apache.rat.testhelpers.FileUtils;
+import org.apache.rat.utils.FileUtils;
 import org.apache.rat.testhelpers.XmlUtils;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
index f4a188099..1f55d2ba0 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractOptionsProvider.java
@@ -170,7 +170,7 @@ public static String[] extractArgs(List<Pair<Option, String[]>> args) {
     }
 
     protected File writeFile(final String name, final Iterable<String> lines) {
-        return org.apache.rat.testhelpers.FileUtils.writeFile(baseDir, name, lines);
+        return org.apache.rat.utils.FileUtils.writeFile(baseDir, name, lines);
     }
 
     final protected DocumentName mkDocName(final String name) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
new file mode 100644
index 000000000..94b23a358
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
@@ -0,0 +1,200 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.testhelpers.data;
+
+
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.stream.Stream;
+import org.apache.commons.cli.Option;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.rat.OptionCollectionParser;
+import org.apache.rat.commandline.Arg;
+import org.apache.rat.ui.AbstractOptionCollection;
+import org.apache.rat.ui.ArgumentTracker;
+import org.apache.rat.utils.DefaultLog;
+
+/**
+ * Generates a list of TestData for executing the Report.
+ * Use of this interface ensures consistent testing across the UIs. Each method
+ * tests an Option from {@link OptionCollectionParser} that must be implemented in the UI.
+ * This differes from the {@link OptionTestDataProvider} in that tests from this set
+ * expect that execptions will be thrown during execution, and tests the xml output.
+ */
+public abstract class AbstractTestDataProvider {
+
+    /** The list of exclude args */
+    static final String[] EXCLUDE_ARGS = {"*.foo", "%regex[[A-Z]\\.bar]", "justbaz"};
+    /** the list of include args */
+    static final String[] INCLUDE_ARGS = {"B.bar", "justbaz"};
+    public final ImmutableList<ImmutablePair<Option, String[]>> NO_OPTIONS = ImmutableList.of(ImmutablePair.nullPair());
+
+    /**
+     * Generates a map of TestData indexed by the testName
+     * @param optionCollection the collection of options for the UI under test.
+     * @return the map of testName to Test Data.
+     */
+    public final Map<String, TestData> getOptionTestMap(final AbstractOptionCollection<?> optionCollection) {
+        Map<String, TestData> map = new TreeMap<>();
+        for (TestData test : getOptionTests(optionCollection)) {
+            map.put(test.getTestName(), test);
+        }
+        return map;
+    }
+
+    /**
+     * Generates a list of test data for Option testing.
+     * This is different from UI testing as this is to test
+     * that the command line is properly parsed into a configuration.
+     * @param optionCollection the collection of options for the UI under test.
+     * @return a set of TestData for the tests.
+     */
+    public final Set<TestData> getOptionTests(final AbstractOptionCollection<?> optionCollection) {
+        // the optionCollection establishes any changes to the Arg values.
+        List<Option> unsupportedOptions = new ArrayList<>(optionCollection.getUnsupportedOptions().getOptions());
+        Set<TestData> result = new TreeSet<>();
+        for (Arg arg : Arg.values()) {
+            if (!arg.isEmpty()) {
+                Stream<Option> options = arg.group().getOptions().stream().filter(opt -> !unsupportedOptions.contains(opt));
+                switch (arg) {
+                    case CONFIGURATION -> options.forEach(opt -> configTest(result, opt));
+                    case CONFIGURATION_NO_DEFAULTS -> options.forEach(opt -> configurationNoDefaultsTest(result, opt));
+                    case COUNTER_MIN -> options.forEach(opt -> counterMinTest(result, opt));
+                    case COUNTER_MAX -> options.forEach(opt -> counterMaxTest(result, opt));
+                    case DRY_RUN -> options.forEach(opt -> dryRunTest(result, opt));
+                    case EDIT_COPYRIGHT -> options.forEach(opt -> editCopyrightTest(result, opt));
+                    case EDIT_ADD -> options.forEach(opt -> editLicenseTest(result, opt));
+                    case EDIT_OVERWRITE -> options.forEach(opt -> editOverwriteTest(result, opt));
+                    case HELP_LICENSES -> options.forEach(opt -> helpLicenses(result, opt));
+                    case EXCLUDE -> options.forEach(opt -> inputExcludeTest(result, opt));
+                    case EXCLUDE_FILE -> options.forEach(opt -> inputExcludeFileTest(result, opt));
+                    case EXCLUDE_PARSE_SCM -> options.forEach(opt -> inputExcludeParsedScmTest(result, opt));
+                    case EXCLUDE_STD -> options.forEach(opt -> inputExcludeStdTest(result, opt));
+                    case EXCLUDE_SIZE -> options.forEach(opt -> inputExcludeSizeTest(result, opt));
+                    case INCLUDE -> options.forEach(opt -> inputIncludeTest(result, opt));
+                    case INCLUDE_FILE -> options.forEach(opt -> inputIncludeFileTest(result, opt));
+                    case INCLUDE_STD -> options.forEach(opt -> inputIncludeStdTest(result, opt));
+                    case SOURCE -> options.forEach(opt -> inputSourceTest(result, opt));
+                    case FAMILIES_APPROVED -> options.forEach(opt -> licenseFamiliesApprovedTest(result, opt));
+                    case FAMILIES_APPROVED_FILE -> options.forEach(opt -> licenseFamiliesApprovedFileTest(result, opt));
+                    case FAMILIES_DENIED -> options.forEach(opt -> licenseFamiliesDeniedTest(result, opt));
+                    case FAMILIES_DENIED_FILE -> options.forEach(opt -> licenseFamiliesDeniedFileTest(result, opt));
+                    case LICENSES_APPROVED -> options.forEach(opt -> licensesApprovedTest(result, opt));
+                    case LICENSES_APPROVED_FILE -> options.forEach(opt -> licensesApprovedFileTest(result, opt));
+                    case LICENSES_DENIED -> options.forEach(opt -> licensesDeniedTest(result, opt));
+                    case LICENSES_DENIED_FILE -> options.forEach(opt -> licensesDeniedFileTest(result, opt));
+                    case LOG_LEVEL -> options.forEach(opt -> logLevelTest(result, opt));
+                    case OUTPUT_ARCHIVE -> options.forEach(opt -> outputArchiveTest(result, opt));
+                    case OUTPUT_FAMILIES -> options.forEach(opt -> outputFamiliesTest(result, opt));
+                    case OUTPUT_FILE -> options.forEach(opt -> outputFileTest(result, opt));
+                    case OUTPUT_LICENSES -> options.forEach(opt -> outputLicensesTest(result, opt));
+                    case OUTPUT_STANDARD -> options.forEach(opt -> outputStandardTest(result, opt));
+                    case OUTPUT_STYLE -> options.forEach(opt -> outputStyleTest(result, opt));
+                }
+            }
+        }
+        validate(result);
+        return result;
+    }
+
+    private void validate(Set<TestData> result) {
+        Set<Option> options = new HashSet<>(Arg.getOptions().getOptions());
+        result.forEach(testData -> options.remove(testData.getOption()));
+        // TODO fix this once deprecated options are removed
+        options.forEach(opt -> DefaultLog.getInstance().warn("Option " + ArgumentTracker.extractKey(opt) + " was not tested."));
+        //assertThat(options).describedAs("All options are not accounted for.").isEmpty();
+    }
+
+    protected abstract void inputExcludeFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputExcludeTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputExcludeStdTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputExcludeParsedScmTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputExcludeSizeTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputIncludeFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputIncludeTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputIncludeStdTest(final Set<TestData> result, final Option option);
+
+    protected abstract void inputSourceTest(final Set<TestData> result, final Option option);
+
+    protected abstract void helpLicenses(final Set<TestData> result, final Option option);
+
+    protected abstract void licensesApprovedFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licensesApprovedTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licensesDeniedTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licensesDeniedFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licenseFamiliesApprovedFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licenseFamiliesApprovedTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licenseFamiliesDeniedFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void licenseFamiliesDeniedTest(final Set<TestData> result, final Option option);
+
+    protected abstract void counterMaxTest(final Set<TestData> result, final Option option);
+
+    protected abstract void counterMinTest(final Set<TestData> result, final Option option);
+
+    /**
+     * Add results to the result list.
+     * @param result the result list.
+     * @param option configuration option we are testing.
+     */
+    protected abstract void configTest(final Set<TestData> result, final Option option);
+
+    protected abstract void configurationNoDefaultsTest(final Set<TestData> result, final Option option);
+
+    protected abstract void dryRunTest(final Set<TestData> result, final Option option);
+
+    protected abstract  void editCopyrightTest(final Set<TestData> result, final Option option);
+
+    protected abstract void editLicenseTest(final Set<TestData> result, final Option option);
+
+    protected abstract void editOverwriteTest(final Set<TestData> result, final Option option);
+
+    protected abstract void logLevelTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputArchiveTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputFamiliesTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputFileTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputLicensesTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputStandardTest(final Set<TestData> result, final Option option);
+
+    protected abstract void outputStyleTest(final Set<TestData> result, final Option option);
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
new file mode 100644
index 000000000..c1fcefdbb
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
@@ -0,0 +1,242 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.testhelpers.data;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+import javax.xml.xpath.XPathExpressionException;
+import org.apache.commons.cli.Option;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.commons.text.WordUtils;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.ui.ArgumentTracker;
+import org.apache.rat.utils.CasedString;
+import org.apache.rat.utils.FileUtils;
+import org.w3c.dom.Document;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * The definition of a test.
+ */
+public final class TestData implements Comparable<TestData> {
+    /** if set, the expected exception from the test. */
+    private Exception expectedException;
+    /** The sub name of the test */
+    private final String name;
+    /** The command line for the test */
+    private final List<ImmutablePair<Option, String[]>> commandLine;
+    /** A function to setup the test in a specific path */
+    private final Consumer<Path> setupFiles;
+    /** A function to test the results of the test. */
+    private final Consumer<ValidatorData> validator;
+
+    /**
+     * Constructs the Test data
+     * @param name the sub name of the test.  May not be {@code null} but may be an empty string.  Should
+     * be specified in Camel case for multiple words.
+     * @param commandLine The command line for the test.  May not be {@code null} but may consist of a single {@link ImmutablePair#nullPair()}.
+     * @param setupFiles the method to set up the files for the test. May not be {@code null}.
+     * @param validator the validator for the results of the test. May not be {@code null}.
+     */
+    public TestData(String name, List<ImmutablePair<Option, String[]>> commandLine,
+             Consumer<Path> setupFiles,
+             Consumer<ValidatorData> validator) {
+        Objects.requireNonNull(name, " name cannot be null");
+        Objects.requireNonNull(commandLine, "commandLine cannot be null");
+        Objects.requireNonNull(setupFiles, "setupFiles cannot be null");
+        Objects.requireNonNull(validator, "validator cannot be null");
+        if (name.contains("/")) {
+            throw new IllegalArgumentException("name may not contain '/', use camel case instead");
+        }
+        if (commandLine.isEmpty()) {
+            throw new IllegalArgumentException("commandLine may not be empty but contain an ImmutablePair.nullPair()");
+        }
+        this.name = name;
+        this.commandLine = commandLine;
+        this.setupFiles = setupFiles;
+        this.validator = validator;
+        this.expectedException = null;
+    }
+
+    @Override
+    public String toString() {
+        return getTestName();
+    }
+
+    /**
+     * Sets the exception expected from this test.
+     * @param expectedException the expected exception.
+     */
+    void setException(Exception expectedException) {
+        this.expectedException = expectedException;
+    }
+
+    /**
+     * The option for the test.  This is the first option specified in the command line.
+     * If the command line is empty this returns {@code null}.
+     * @return the first option in the command line or {@code null} if there is no option.
+     */
+    public Option getOption() {
+        return commandLine.get(0).getLeft();
+    }
+
+    /**
+     * Get the sub name for this test.
+     * @return the sub name for this test.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gets the expected excepton or {@code null} if not exception is expected.
+     * @return the expected excepton or {@code null} if not exception is expected.
+     */
+    public Exception getExpectedException() {
+        return expectedException;
+    }
+
+    /**
+     * Determines if the test is expecting an exception.
+     * @return {@code true} if the test is expecting to throw an exception.
+     */
+    public boolean expectingException() {
+        return expectedException != null;
+    }
+
+    /**
+     * Gets the command line as the string objects that are normally parsed by the
+     * command line parser.
+     * @return the command line strings.
+     */
+    public String[] getCommandLine() {
+        return getCommandLine(null);
+    }
+
+    /**
+     * Gets the command line as the string objects that are normally parsed by the
+     * command line parser. The result will include "--" to terminate a trailing multi
+     * argument option.
+     * @param workingDir the directory to add to the command line.  May be {@code null}.
+     * @return the command line strings.
+     */
+    public String[] getCommandLine(String workingDir) {
+        List<String> args = new ArrayList<>(commandLine.size());
+        final boolean[] lastWasMultiArg = {false};
+        commandLine.forEach(pair -> {
+            if (pair.getKey() != null) {
+                if (pair.getKey().hasLongOpt()) {
+                    args.add("--" + pair.getKey().getLongOpt());
+                } else {
+                    args.add("-" + pair.getKey().getOpt());
+                }
+                if (pair.getValue() != null) {
+                    args.addAll(Arrays.asList(pair.getValue()));
+                }
+                lastWasMultiArg[0] = pair.getKey().hasArgs();
+            } else {
+                lastWasMultiArg[0] = false;
+            }
+        });
+        if (lastWasMultiArg[0]) {
+            args.add("--");
+        }
+        if (workingDir != null) {
+            args.add(workingDir);
+        }
+        return args.toArray(new String[0]);
+    }
+
+    /**
+     * Get the arguments for the command line.
+     * @return the argumentsfor the command line as Option, String[] pairs.
+     */
+    public List<? extends Pair<Option, String[]>> getArgs() {
+        return commandLine;
+    }
+
+    /**
+     * Gets the validator for the test.
+     * @return the validator for the test.
+     */
+    public Consumer<ValidatorData> getValidator() {
+        return validator;
+    }
+
+    /**
+     * Sets up the files for the test.
+     * @param path the path to use as the base directory.  Subdirectories and files may be added
+     * to this path.
+     */
+    public void setupFiles(Path path) {
+        FileUtils.mkDir(path.toFile());
+        setupFiles.accept(path);
+    }
+
+    /**
+     * Gets the test name.  This is the option concatenated with the name.
+     * @return the unique test name
+     */
+    public String getTestName() {
+         new ArrayList<>();
+        String result = null;
+        if (getOption() == null) {
+            result = name + "_DefaultTest";
+        } else {
+            result = new CasedString(CasedString.StringCase.KEBAB, ArgumentTracker.extractKey(getOption())).toString();
+            if (!name.isEmpty()) {
+                result += "/" + name;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Gets the test name as a class name.  This is based on the option concatenated with the name.
+     * @return the unique Java class name
+     */
+    public String getClassName() {
+        if (getOption() == null) {
+            return WordUtils.capitalize(name) + "_DefaultTest";
+        } else {
+            List<String> parts = new ArrayList<>(Arrays.asList(new CasedString(CasedString.StringCase.KEBAB, ArgumentTracker.extractKey(getOption())).getSegments()));
+            if (!name.isEmpty()) {
+                parts.addAll(Arrays.asList(new CasedString(CasedString.StringCase.CAMEL, name).getSegments()));
+            }
+            return CasedString.StringCase.PASCAL.assemble(parts.toArray(new String[0]));
+        }
+    }
+
+    @Override
+    public int compareTo(TestData other) {
+        return getTestName().compareTo(other.getTestName());
+    }
+
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java
new file mode 100644
index 000000000..55185d668
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.testhelpers.data;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import org.apache.rat.ConfigurationException;
+import org.apache.rat.ReportConfiguration;
+import org.apache.rat.Reporter;
+import org.apache.rat.api.RatException;
+import org.apache.rat.configuration.XMLConfig;
+import org.apache.rat.configuration.XMLConfigurationWriter;
+import org.apache.rat.document.DocumentName;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import static org.apache.rat.configuration.XMLConfigurationReader.nodeListConsumer;
+
+/**
+ * The validator for test data.
+ */
+public final class ValidatorData {
+    /** The report output */
+    private final Reporter.Output output;
+    /** the base directory where the test setup was created */
+    private final Path baseDir;
+
+    /**
+     * Constructor.
+     * @param output The report output.
+     * @param baseDir the directory where the test setup was created.
+     */
+    public ValidatorData(final Reporter.Output output, final String baseDir) {
+        this.output = output;
+        this.baseDir = Paths.get(baseDir);
+    }
+
+    /**
+     * Gets the directory where the test setup was created as a DocumentName.
+     * @return the DocumentName for the baseDir directory.
+     */
+    public DocumentName getBaseName() {
+        return DocumentName.builder(baseDir.toFile()).build();
+    }
+
+    /**
+     * Creates a DocumentName for a file name.  The root of the document Name will be the baseDir.
+     * @param fileName the file name to create a document name for.
+     * @return the Document name for the file.
+     */
+    public DocumentName mkDocName(String fileName) {
+        return DocumentName.builder().setBaseName(baseDir.toFile()).setName(fileName).build();
+    }
+
+    public Reporter.Output getOutput() {
+        return output;
+    }
+    /**
+     * Gets the document that was generated during execution.
+     * @return the document that was generated during execution.
+     */
+    public Document getDocument() {
+        return output.getDocument();
+    }
+
+    /**
+     * Gets the claim statistics from the run
+     * @return the ClaimStatistic from the run.
+     */
+    public ClaimStatistic getStatistic() {
+        return output.getStatistic();
+    }
+
+    /**
+     * Gets the configuration from the run.
+     * @return the configuration from the run.
+     */
+    public ReportConfiguration getConfiguration() {
+        return output.getConfiguration();
+    }
+
+    public Path getBaseDir() {
+        return baseDir;
+    }
+
+}

From 84a407924f46a8405465df68415dd6959356ff95 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 10 May 2026 15:26:40 +0100
Subject: [PATCH 05/36] created testhelper and updated tests

---
 .../src/main/java/org/apache/rat/Report.java  |   63 +-
 .../org/apache/rat/ReportConfiguration.java   |  201 ++-
 .../main/java/org/apache/rat/Reporter.java    |  296 ++--
 .../java/org/apache/rat/commandline/Arg.java  |    7 +-
 .../apache/rat/commandline/StyleSheets.java   |   37 +-
 .../config/exclusion/ExclusionProcessor.java  |   84 +-
 .../configuration/XMLConfigurationReader.java |    4 +-
 .../apache/rat/license/LicenseSetFactory.java |   30 +
 .../org/apache/rat/report/IReportable.java    |    2 +-
 .../rat/report/claim/ClaimStatistic.java      |  115 ++
 .../org/apache/rat/walker/FileListWalker.java |    4 +-
 .../rat/walker/IReportableListWalker.java     |    4 +-
 .../java/org/apache/rat/walker/Walker.java    |    2 +-
 .../main/resources/org/apache/rat/xhtml5.xsl  |  354 +++++
 .../org/apache/rat/OptionCollectionTest.java  |    2 +-
 .../apache/rat/ReportConfigurationTest.java   |  101 +-
 .../apache/rat/ReporterOptionsProvider.java   |  289 ++--
 .../org/apache/rat/ReporterOptionsTest.java   |   12 +-
 .../java/org/apache/rat/ReporterTest.java     |  108 +-
 .../XMLConfigurationReaderTest.java           |   17 +-
 .../AbstractConfigurationOptionsProvider.java |    4 +-
 .../apache/rat/testhelpers/BaseOption.java    |   25 +
 .../rat/testhelpers/BaseOptionCollection.java |   24 +
 .../apache/rat/testhelpers/TestingLog.java    |   11 +-
 .../data/AbstractTestDataProvider.java        |    8 +-
 .../rat/testhelpers/data/DataUtils.java       |  142 ++
 .../data/ReportTestDataProvider.java          | 1282 +++++++++++++++++
 .../apache/rat/testhelpers/data/TestData.java |   18 +-
 .../rat/testhelpers/data/ValidatorData.java   |   17 -
 .../anttasks/ResourceCollectionContainer.java |    2 +-
 30 files changed, 2826 insertions(+), 439 deletions(-)
 create mode 100644 apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java

diff --git a/apache-rat-core/src/main/java/org/apache/rat/Report.java b/apache-rat-core/src/main/java/org/apache/rat/Report.java
index 5f5f4cb35..5d9c914f2 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Report.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Report.java
@@ -19,8 +19,13 @@
 package org.apache.rat;
 
 import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
 
 import org.apache.commons.cli.Options;
+import org.apache.commons.io.function.IOSupplier;
+import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.document.RatDocumentAnalysisException;
 import org.apache.rat.help.Help;
 import org.apache.rat.utils.DefaultLog;
@@ -42,34 +47,66 @@ public final class Report {
     public static void main(final String[] args) throws Exception {
         DefaultLog.getInstance().info(new VersionInfo().toString());
 
+
         if (args == null || args.length == 0) {
             DefaultLog.getInstance().info("Please use the \"--help\" option to see a " +
                     "list of valid commands and options, as you did not provide any arguments.");
             System.exit(0);
         }
 
-        ReportConfiguration configuration = OptionCollection.parseCommands(new File("."), args, Report::printUsage);
-        if (configuration != null) {
-            configuration.validate(DefaultLog.getInstance()::error);
-            Reporter reporter = new Reporter(configuration);
-            reporter.output();
-            reporter.writeSummary(DefaultLog.getInstance().asWriter());
+        Reporter.Output result = generateReport(CLIOptionCollection.INSTANCE, new File("."), args);
+        if (result != null) {
+            result.writeSummary(DefaultLog.getInstance().asWriter());
 
-            if (configuration.getClaimValidator().hasErrors()) {
-                configuration.getClaimValidator().logIssues(reporter.getClaimsStatistic());
+            if (result.getConfiguration().getClaimValidator().hasErrors()) {
+                result.getConfiguration().getClaimValidator().logIssues(result.getStatistic());
                 throw new RatDocumentAnalysisException(format("Issues with %s",
                         String.join(", ",
-                                configuration.getClaimValidator().listIssues(reporter.getClaimsStatistic()))));
+                                result.getConfiguration().getClaimValidator().listIssues(result.getStatistic()))));
             }
         }
     }
 
     /**
-     * Prints the usage message on {@code System.out}.
-     * @param opts The defined options.
+     * Prints the usage message on the specified output stream.
+     * @param out The OutputStream supplier
      */
-    private static void printUsage(final Options opts) {
-        new Help(System.out).printUsage(opts);
+    private static void printUsage(final Options options, final IOSupplier<OutputStream> out) {
+        try (OutputStream stream = out.get();
+             PrintWriter writer = new PrintWriter(stream)) {
+            new Help(writer).printUsage(options);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Generates the report
+     * @param workingDirectory the directory that we are executing in
+     * @param args the arguments from the command line.
+     * @return The Client output.
+     * @throws Exception on error.
+     */
+    static Reporter.Output generateReport(final CLIOptionCollection optionCollection, final File workingDirectory, final String[] args) throws Exception {
+        Reporter.Output output = null;
+        OptionCollectionParser optionParser = new OptionCollectionParser(optionCollection);
+        ArgumentContext argumentContext = optionParser.parseCommands(workingDirectory, args);
+        ReportConfiguration configuration = argumentContext.getConfiguration();
+        if (configuration != null) {
+            if (argumentContext.getCommandLine().hasOption(CLIOptionCollection.HELP)) {
+                printUsage(optionCollection.getOptions(), argumentContext.getConfiguration().getOutput());
+            } else if (!configuration.hasSource()) {
+                String msg = "No directories or files specified for scanning. Did you forget to close a multi-argument option?";
+                DefaultLog.getInstance().error(msg);
+                printUsage(optionCollection.getOptions(), argumentContext.getConfiguration().getOutput());
+            } else {
+                configuration.validate();
+                Reporter reporter = new Reporter(configuration);
+                output = reporter.execute();
+                output.format(configuration);
+            }
+        }
+        return output;
     }
 
     private Report() {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index 799dfaf53..82ce49204 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -34,18 +34,25 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.SortedSet;
-import java.util.function.Consumer;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 
 import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.io.output.CloseShieldOutputStream;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.rat.analysis.IHeaderMatcher;
+import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.config.AddLicenseHeaders;
 import org.apache.rat.config.exclusion.ExclusionProcessor;
 import org.apache.rat.config.exclusion.StandardCollection;
 import org.apache.rat.config.results.ClaimValidator;
+import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.configuration.builders.AnyBuilder;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
@@ -55,11 +62,17 @@
 import org.apache.rat.license.LicenseSetFactory;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
 import org.apache.rat.report.IReportable;
+import org.apache.rat.report.RatReport;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.xml.writer.IXmlWriter;
+import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log.Level;
 import org.apache.rat.utils.ReportingSet;
 import org.apache.rat.walker.FileListWalker;
 import org.apache.rat.walker.IReportableListWalker;
+import org.w3c.dom.Node;
+import org.xml.sax.SAXException;
 
 /**
  * A configuration object is used by the front end to invoke the
@@ -68,6 +81,8 @@
  */
 public class ReportConfiguration {
 
+    /** The IODescriptor for System.out */
+    public static final IODescriptor<OutputStream> SYSTEM_OUT = new  IODescriptor<>("System.out", () -> CloseShieldOutputStream.wrap(System.out));
     /**
      * The styles of processing for various categories of documents.
      */
@@ -117,11 +132,11 @@ public String desc() {
     /**
      * The IOSupplier that provides the output stream to write the report to.
      */
-    private IOSupplier<OutputStream> out;
+    private IODescriptor<OutputStream> out;
     /**
      * The IOSupplier that provides the stylesheet to style the XML output.
      */
-    private IOSupplier<InputStream> styleSheet;
+    private IODescriptor<InputStream> styleSheet;
 
     /**
      * A list of files to read file names from.
@@ -176,6 +191,10 @@ public ReportConfiguration() {
         reportables = new ArrayList<>();
     }
 
+    public Serde serde() {
+        return new Serde();
+    }
+
     /**
      * Report the excluded files to the appendable object.
      * @param appendable the appendable object to write to.
@@ -427,7 +446,7 @@ public void addIncludedPatterns(final Iterable<String> patterns) {
     }
 
     /**
-     * Get the DocumentNameMatcher that excludes files found in the directory tree..
+     * Get the DocumentNameMatcher that excludes files found in the directory tree.
      * @param baseDir the DocumentName for the base directory.
      * @return the DocumentNameMatcher for the base directory.
      */
@@ -441,6 +460,15 @@ public DocumentNameMatcher getDocumentExcluder(final DocumentName baseDir) {
      * the report with.
      */
     public IOSupplier<InputStream> getStyleSheet() {
+        return styleSheet.ioSupplier();
+    }
+
+    /**
+     * Gets the IODescriptor of the style sheet.
+     * @return the Supplier of the InputStream that is the XSLT style sheet to style
+     * the report with.
+     */
+    public IODescriptor<InputStream> getStyleSheetDescriptor() {
         return styleSheet;
     }
 
@@ -450,7 +478,7 @@ public IOSupplier<InputStream> getStyleSheet() {
      * multiple times.
      * @param styleSheet the XSLT style sheet to style the report with.
      */
-    public void setStyleSheet(final IOSupplier<InputStream> styleSheet) {
+    public void setStyleSheet(final IODescriptor<InputStream> styleSheet) {
         this.styleSheet = styleSheet;
     }
 
@@ -462,7 +490,7 @@ public void setStyleSheet(final IOSupplier<InputStream> styleSheet) {
      */
     public void setFrom(final Defaults defaults) {
         licenseSetFactory.add(defaults.getLicenseSetFactory());
-        if (getStyleSheet() == null) {
+        if (getStyleSheetDescriptor() == null) {
             setStyleSheet(StyleSheets.PLAIN.getStyleSheet());
         }
         defaults.getStandardExclusion().forEach(this::addExcludedCollection);
@@ -498,19 +526,18 @@ public void setStyleSheet(final URI styleSheet) {
      */
     public void setStyleSheet(final URL styleSheet) {
         Objects.requireNonNull(styleSheet, "Stylesheet file must not be null");
-        setStyleSheet(styleSheet::openStream);
+        setStyleSheet(new IODescriptor<>(styleSheet.toString(), styleSheet::openStream));
     }
 
     /**
      * Sets the supplier for the output stream. The supplier may be called multiple
      * times to provide the stream. Suppliers should prepare streams that are
      * appended to and that can be closed. If an {@code OutputStream} should not be
-     * closed consider wrapping it in a {@code CloseShieldOutputStream}
+     * closed consider wrapping it in a {@code NoCloseOutputStream}
      * @param out The OutputStream supplier that provides the output stream to write
      * the report to. A null value will use System.out.
-     * @see CloseShieldOutputStream
      */
-    public void setOut(final IOSupplier<OutputStream> out) {
+    public void setOut(final IODescriptor<OutputStream> out) {
         this.out = out;
     }
 
@@ -518,7 +545,7 @@ public void setOut(final IOSupplier<OutputStream> out) {
      * Sets the OutputStream supplier to use the specified file. The file may be
      * opened and closed several times. File is deleted first and then may be
      * repeatedly opened in append mode.
-     * @see #setOut(IOSupplier)
+     * @see #setOut(IODescriptor)
      * @param file The file to create the supplier with.
      */
     public void setOut(final File file) {
@@ -534,7 +561,7 @@ public void setOut(final File file) {
         if (!parent.mkdirs() && !parent.isDirectory()) {
             DefaultLog.getInstance().warn("Unable to create directory: " + file.getParentFile());
         }
-        setOut(() -> new FileOutputStream(file, true));
+        setOut(new IODescriptor<>(file.toString(), () -> new FileOutputStream(file, true)));
     }
 
     /**
@@ -543,7 +570,15 @@ public void setOut(final File file) {
      * @return The supplier of the output stream to write the report to.
      */
     public IOSupplier<OutputStream> getOutput() {
-        return out == null ? () -> CloseShieldOutputStream.wrap(System.out) : out;
+        return getOutputDescriptor().ioSupplier();
+    }
+
+    /**
+     * Returns the output IODescriptor.
+     * @return The IODescriptor of the output stream to write the report to.
+     */
+    public IODescriptor<OutputStream> getOutputDescriptor() {
+        return out == null ? SYSTEM_OUT : out;
     }
 
     /**
@@ -827,19 +862,145 @@ public LicenseSetFactory getLicenseSetFactory() {
 
     /**
      * Validates that the configuration is valid.
-     * @param logger String consumer to log warning messages to.
      * @throws ConfigurationException on configuration error.
      */
-    public void validate(final Consumer<String> logger) {
+    public void validate() {
         if (!hasSource()) {
             String msg = "At least one source must be specified";
-            logger.accept(msg);
+            DefaultLog.getInstance().error(msg);
             throw new ConfigurationException(msg);
         }
-        if (licenseSetFactory.getLicenses(LicenseFilter.ALL).isEmpty()) {
-            String msg = "You must specify at least one license";
-            logger.accept(msg);
-            throw new ConfigurationException(msg);
+        licenseSetFactory.validate();
+    }
+
+    public class Serde {
+        /**
+         * Writes the configuration as an XML document to the appendable.
+         *
+         * @param appendable the Appendable to write to.
+         * @throws IOException on error.
+         */
+        public void serialize(final Appendable appendable) throws IOException {
+            try (IXmlWriter writer = new XmlWriter(appendable)) {
+                writer.openElement("ReportConfiguration")
+                        .attribute("addingLicenses", Boolean.toString(addingLicenses))
+                        .attribute("addingLicensesForced", Boolean.toString(addingLicensesForced))
+                        .attribute("listFamilies", listFamilies.name())
+                        .attribute("listLicenses", listLicenses.name())
+                        .attribute("dryRun", Boolean.toString(dryRun))
+                        .attribute("archiveProcessing", getArchiveProcessing().name())
+                        .attribute("standardProcessing", getStandardProcessing().name())
+                        .attribute("stylesheet", styleSheet.name())
+                        .attribute("output", out.name());
+                if (StringUtils.isNotEmpty(copyrightMessage)) {
+                    writer.openElement("copyrightMessage").content(copyrightMessage).closeElement();
+                }
+                writer.openElement("sources");
+                for (File f : sources) {
+                    writer.openElement("source").attribute("name", f.getName()).closeElement();
+                }
+                writer.closeElement("sources").openElement("reportables");
+                for (IReportable reportable : reportables) {
+                    writer.openElement("reportable")
+                            .attribute("baseName", reportable.name().getBaseName())
+                            .attribute("name", reportable.name().toString())
+                            .attribute("class", reportable.getClass().getName()).closeElement();
+                }
+                writer.closeElement();
+
+                exclusionProcessor.serde().serialize(writer);
+
+                writer.openElement("claimValidator");
+                for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+                    writer.openElement("claimCounter")
+                            .attribute("name", counter.name()).attribute("min", Integer.toString(claimValidator.getMin(counter)))
+                            .attribute("max", Integer.toString(claimValidator.getMax(counter))).closeElement();
+                }
+                writer.closeElement();
+            } catch (IOException e) {
+                throw e;
+            } catch (Exception e) {
+                throw new IOException(e);
+            }
+        }
+
+        public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final DocumentName workingDirectory) throws IOException {
+            DocumentBuilder builder;
+            try {
+                builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+            } catch (ParserConfigurationException e) {
+                throw new ConfigurationException("Unable to create DOM builder", e);
+            }
+            org.w3c.dom.Document document;
+            try (InputStream stream = inputStreamSupplier.get()) {
+                document = builder.parse(stream);
+            } catch (SAXException e) {
+                throw new IOException("Unable to read input", e);
+            }
+            Node node = document.getDocumentElement();
+            if (!node.getNodeName().equals("ReportConfiguration")) {
+                throw new IOException("Invalid ReportConfiguration");
+            }
+            Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+            addingLicensesForced = Boolean.parseBoolean(attributes.get("addingLicensesForced"));
+            listFamilies = LicenseFilter.valueOf(attributes.get("listFamilies"));
+            listLicenses = LicenseFilter.valueOf(attributes.get("listLicenses"));
+            dryRun = Boolean.parseBoolean(attributes.get("dryRun"));
+            archiveProcessing = Processing.valueOf(attributes.get("archiveProcessing"));
+            standardProcessing = Processing.valueOf(attributes.get("standardProcessing"));
+            String styleName = attributes.get("stylesheet");
+            if (styleName != null) {
+                styleSheet = StyleSheets.getStyleSheet(styleName, workingDirectory);
+            }
+            String outputName = attributes.get("output");
+            if (outputName != null) {
+                if (outputName.equals(ReportConfiguration.SYSTEM_OUT.name())) {
+                    out = ReportConfiguration.SYSTEM_OUT;
+                } else {
+                    out = IODescriptor.output(outputName, workingDirectory);
+                }
+            }
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("source"), lNode -> {
+                Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+                addSource(new File(nAttributes.get("name")));
+            });
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("reportable"), lNode -> {
+                Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+                DocumentName documentName = DocumentName.builder().setBaseName(nAttributes.get("baseName"))
+                        .setName(nAttributes.get("name")).build();
+                addSource(new DeserializedReportable(documentName));
+            });
+
+            exclusionProcessor.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("claimCounter"), lNode -> {
+                Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+                ClaimStatistic.Counter counter = ClaimStatistic.Counter.valueOf(nAttributes.get("name"));
+                claimValidator.setMin(counter, Integer.parseInt(nAttributes.get("min")));
+                claimValidator.setMax(counter, Integer.parseInt(nAttributes.get("max")));
+            });
+        }
+    }
+
+    private record DeserializedReportable(DocumentName name) implements IReportable {
+        @Override
+        public void run(final RatReport report) throws RatException {
+            throw new RatException("Attempt to run a deserialized reportable");
         }
     }
+
+    public record IODescriptor<T>(String name, IOSupplier<T> ioSupplier) {
+        /**
+         * Creates an output IODescriptor for the file name within the working directory.
+         * @param name the name of the file to open.
+         * @param workingDirectory the working directory for the file.
+         * @return the Output IODescriptor.
+         */
+        static IODescriptor<OutputStream> output(final String name, final DocumentName workingDirectory) {
+            DocumentName docName = workingDirectory.resolve(name);
+            return new IODescriptor<OutputStream>(name, () -> new FileOutputStream(docName.asFile()));
+        }
+    };
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index 6ca704ca3..34425bde1 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -18,16 +18,19 @@
  */
 package org.apache.rat;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.io.Writer;
+import java.io.StringReader;
 import java.nio.charset.StandardCharsets;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
@@ -38,6 +41,7 @@
 
 import org.apache.commons.io.function.IOSupplier;
 import org.apache.rat.api.RatException;
+import org.apache.rat.document.DocumentName;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.report.claim.ClaimStatistic;
@@ -45,6 +49,8 @@
 import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.StandardXmlFactory;
 import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
 
 /**
  * Class that executes the report as defined in a {@link ReportConfiguration} and stores
@@ -55,15 +61,14 @@ public class Reporter {
     /**  Format used for listing licenses. */
     private static final String LICENSE_FORMAT = "%s:\t%s%n\t\t%s%n";
 
-    /** The XML output document */
-    private Document document;
-
-    /** Statistics generated as the report was built */
-    private ClaimStatistic statistic;
-
     /** The configuration for the report */
     private final ReportConfiguration configuration;
 
+    /**
+     * The output from the execution.
+     */
+    private Output output;
+
     /**
      * Create the reporter.
      *
@@ -75,83 +80,39 @@ public Reporter(final ReportConfiguration configuration) {
 
     /**
      * Executes the report and builds the output.
-     * This method will build the internal XML document if it does not already exist.
-     * If this method or either of the {@link #output()} methods have already been called this method will return
-     * the previous results.
-     * @return the claim statistics.
+     * @return the Output object.
      * @throws RatException on error.
      */
-    public ClaimStatistic execute() throws RatException  {
-        if (document == null || statistic == null) {
-            try {
-                if (configuration.hasSource()) {
-                    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-                    Writer outputWriter = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
-                    try (XmlWriter writer = new XmlWriter(outputWriter)) {
-                        statistic = new ClaimStatistic();
-                        RatReport report = XmlReportFactory.createStandardReport(writer, statistic, configuration);
-                        report.startReport();
-                        configuration.getSources().build().run(report);
-                        report.endReport();
-                    }
-                    InputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
-                    document = StandardXmlFactory.documentBuilder().parse(inputStream);
-                } else {
-                    document = StandardXmlFactory.documentBuilder().newDocument();
-                    statistic = new ClaimStatistic();
+    public Output execute() throws RatException {
+        try {
+            Output.Builder builder = Output.builder().configuration(configuration);
+            if (configuration.hasSource()) {
+                StringBuilder sb = new StringBuilder();
+                try (XmlWriter writer = new XmlWriter(sb)) {
+                    writer.startDocument();
+                    ClaimStatistic statistic = new ClaimStatistic();
+                    builder.statistic(statistic);
+                    RatReport report = XmlReportFactory.createStandardReport(writer, statistic, configuration);
+                    report.startReport();
+                    configuration.getSources().build().run(report);
+                    report.endReport();
+                    InputSource inputSource = new InputSource(new StringReader(sb.toString()));
+                    builder.document(StandardXmlFactory.documentBuilder().parse(inputSource));
                 }
-            }  catch (Exception e) {
-                throw RatException.makeRatException(e);
             }
+            this.output = builder.build();
+            return output;
+        } catch (Exception e) {
+            throw RatException.makeRatException(e);
         }
-        return statistic;
-    }
-
-    /**
-     * Get the claim statistics from the run.
-     *
-     * @return the claim statistics.
-     */
-    public ClaimStatistic getClaimsStatistic() {
-        return statistic;
-    }
-
-    /**
-     * Outputs the report using the stylesheet and output specified in the configuration.
-     * @return the Claim statistic from the run.
-     * @throws RatException on error.
-     */
-    public ClaimStatistic output() throws RatException {
-        return output(configuration.getStyleSheet(), configuration.getOutput());
     }
 
     /**
-     * Outputs the report to the specified output using the stylesheet. It is safe to call this method more than once
-     * in order to generate multiple reports from the same run.
-     *
-     * @param stylesheet the style sheet to use for XSLT formatting.
-     * @param output the output stream to write to.
-     * @return the Claim statistic for the run.
-     * @throws RatException on error.
+     * Gets the output from the last {@link #execute} call or {@code null} if {@link #execute} has not been called.
+     * @return the output
      */
-    public ClaimStatistic output(final IOSupplier<InputStream> stylesheet, final IOSupplier<OutputStream> output) throws RatException {
-        ClaimStatistic result = execute();
-        TransformerFactory tf = TransformerFactory.newInstance();
-        Transformer transformer;
-        try (OutputStream out = output.get();
-             InputStream styleIn = stylesheet.get()) {
-            transformer = tf.newTransformer(new StreamSource(styleIn));
-            transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
-            transformer.setOutputProperty(OutputKeys.METHOD, "xml");
-            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
-            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
-            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
-            transformer.transform(new DOMSource(document),
-                    new StreamResult(new OutputStreamWriter(out, StandardCharsets.UTF_8)));
-            return result;
-        } catch (TransformerException | IOException e) {
-            throw new RatException(e);
-        }
+    public Output getOutput() {
+        return output;
     }
 
     /**
@@ -168,27 +129,176 @@ public static void listLicenses(final ReportConfiguration configuration, final L
                             lic.getLicenseFamily().getFamilyName(), lic.getNote()));
             pw.println();
         }
+        return statistic;
     }
 
     /**
-     * Writes a text summary of issues with the run.
-     * @param appendable the appendable to write to.
-     * @throws IOException on error.
+     * The output from a report run.
      */
-    public void writeSummary(final Appendable appendable) throws IOException {
-        appendable.append("RAT summary:").append(System.lineSeparator());
-        for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
-            appendable.append("  ").append(counter.displayName()).append(":  ")
-                    .append(Integer.toString(getClaimsStatistic().getCounter(counter)))
-                    .append(System.lineSeparator());
+    public static final class Output {
+        /** The XML output document */
+        private final Document document;
+        /**
+         * The claim statics from the execution that generated the document.
+         * May be empty if the Document was read from disk.
+         */
+        private final ClaimStatistic statistic;
+        /**
+         * The configuration that generated the document
+         */
+        private final ReportConfiguration configuration;
+
+        /**
+         * Create an output with statistics.
+         * @param builder the Builder
+         */
+        private Output(final Builder builder) {
+            this.document = builder.document;
+            this.statistic = builder.statistic == null ? new ClaimStatistic() : builder.statistic;
+            this.configuration = builder.configuration == null ? new ReportConfiguration() : builder.configuration;
         }
-    }
 
-    /**
-     * Gets the document that was generated during execution.
-     * @return the document that was generated during execution.
-     */
-    public Document getDocument() {
-        return document;
+        public static Builder builder() {
+            return new Builder();
+        }
+
+        /**
+         * Gets the document that was generated during execution.
+         * @return the document that was generated during execution.
+         */
+        public Document getDocument() {
+            return document;
+        }
+
+        public ClaimStatistic getStatistic() {
+            return statistic;
+        }
+
+        public ReportConfiguration getConfiguration() {
+            return configuration;
+        }
+        /**
+         * Formats the report to the output and using the stylesheet found in the report configuration.
+         *
+         * @param config s RAT report configuration.
+         * @throws RatException on error.
+         */
+        public void format(final ReportConfiguration config) throws RatException {
+            format(config.getStyleSheet(), config.getOutput());
+        }
+
+        /**
+         * Formats the report to the specified output using the stylesheet. It is safe to call this method more than once
+         * in order to generate multiple reports from the same run.
+         *
+         * @param stylesheet the style sheet to use for XSLT formatting.
+         * @param output the output stream to write to.
+         * @throws RatException on error.
+         */
+        public void format(final IOSupplier<InputStream> stylesheet, final IOSupplier<OutputStream> output) throws RatException {
+            TransformerFactory tf = TransformerFactory.newInstance();
+            Transformer transformer;
+            try (OutputStream out = output.get();
+                 InputStream styleIn = stylesheet.get()) {
+                transformer = tf.newTransformer(new StreamSource(styleIn));
+                transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
+                transformer.setOutputProperty(OutputKeys.METHOD, "xml");
+                transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+                transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
+                transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
+                transformer.transform(new DOMSource(document),
+                        new StreamResult(new OutputStreamWriter(out, StandardCharsets.UTF_8)));
+            } catch (TransformerException | IOException e) {
+                throw new RatException(e);
+            }
+        }
+
+        /**
+         * Writes a text summary of issues with the run.
+         * @param appendable the appendable to write to.
+         * @throws IOException on error.
+         */
+        public void writeSummary(final Appendable appendable) throws IOException {
+            appendable.append("RAT summary:").append(System.lineSeparator());
+            for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+                appendable.append("  ").append(counter.displayName()).append(":  ")
+                        .append(Integer.toString(statistic.getCounter(counter)))
+                        .append(System.lineSeparator());
+            }
+        }
+
+        public static final class Builder {
+            /** The document that was generated */
+            private Document document;
+            /**
+             * The claim statistic from the execution that generated the document.
+             * May be empty if the Document was read from disk.
+             */
+            private ClaimStatistic statistic;
+            /**
+             * The configuration that generated the document
+             */
+            private ReportConfiguration configuration;
+
+            public Builder document(final Document document) {
+                this.document = document;
+                return this;
+            }
+
+            public Builder document(final String fileName, final DocumentName workingDirectory) {
+                DocumentBuilder builder;
+                try {
+                    builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+                } catch (ParserConfigurationException e) {
+                    throw new ConfigurationException("Unable to create DOM builder", e);
+                }
+
+                File inputFile = workingDirectory.resolve(fileName).asFile();
+                try (InputStream inputStream = new FileInputStream(inputFile)) {
+                    this.document = builder.parse(inputStream);
+                } catch (SAXException | IOException e) {
+                    throw new ConfigurationException("Unable to read file: " + inputFile, e);
+                }
+                return this;
+            }
+
+            public Output build() {
+                return new Output(this);
+            }
+
+            public Builder statistic(final ClaimStatistic statistic) {
+                this.statistic = statistic;
+                return this;
+            }
+
+            public Builder statistic(final String fileName, final DocumentName workingDirectory) {
+                File sourceFile = workingDirectory.resolve(fileName).asFile();
+                try {
+                    ClaimStatistic statistic = new ClaimStatistic();
+                    statistic.serde().deserialize(() -> new FileInputStream(sourceFile));
+                    this.statistic = statistic;
+                    return this;
+                } catch (IOException e) {
+                    throw new ConfigurationException("Unable to read file: " + sourceFile, e);
+                }
+            }
+
+            public Builder configuration(final ReportConfiguration configuration) {
+                this.configuration = configuration;
+                return this;
+            }
+
+            public Builder configuration(final String fileName, final DocumentName workingDirectory) {
+                File configurationFile = workingDirectory.resolve(fileName).asFile();
+                try {
+                    ReportConfiguration config = new ReportConfiguration();
+                    config.serde().deserialize(() -> new FileInputStream(configurationFile), workingDirectory);
+                    this.configuration = config;
+                    return this;
+                } catch (IOException e) {
+                    throw new ConfigurationException("Unable to read file: " + configurationFile, e);
+                }
+            }
+        }
     }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
index 314e9c276..922aea630 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
@@ -38,7 +38,6 @@
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.io.IOUtils;
-import org.apache.commons.io.output.CloseShieldOutputStream;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.rat.ConfigurationException;
 import org.apache.rat.Defaults;
@@ -518,14 +517,14 @@ public enum Arg {
                 if ("x".equals(key)) {
                     // display deprecated message.
                     context.getCommandLine().hasOption("x");
-                    context.getConfiguration().setStyleSheet(StyleSheets.getStyleSheet("xml"));
+                    context.getConfiguration().setStyleSheet(StyleSheets.getStyleSheet("xml", context.getWorkingDirectory()));
                 } else {
                     String[] style = context.getCommandLine().getOptionValues(selected);
                     if (style.length != 1) {
                         DefaultLog.getInstance().error("Please specify a single stylesheet");
                         throw new ConfigurationException("Please specify a single stylesheet");
                     }
-                    context.getConfiguration().setStyleSheet(StyleSheets.getStyleSheet(style[0]));
+                    context.getConfiguration().setStyleSheet(StyleSheets.getStyleSheet(style[0], context.getWorkingDirectory()));
                 }
             }),
 
@@ -625,7 +624,7 @@ public enum Arg {
                 } catch (ParseException e) {
                     // we write to system out by default.
                     context.logParseException(e, selected, "System.out");
-                    context.getConfiguration().setOut(() -> CloseShieldOutputStream.wrap(System.out)); // NOSONAR
+                    context.getConfiguration().setOut(ReportConfiguration.SYSTEM_OUT);
                 }
             }),
 
diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
index c73a9e4ef..f9e47cc2b 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
@@ -21,12 +21,11 @@
 import java.io.InputStream;
 import java.net.URL;
 import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.Objects;
 
-import org.apache.commons.io.function.IOSupplier;
 import org.apache.rat.ConfigurationException;
+import org.apache.rat.ReportConfiguration;
+import org.apache.rat.document.DocumentName;
 
 import static java.lang.String.format;
 
@@ -49,7 +48,11 @@ public enum StyleSheets {
     /**
      * The plain style sheet. The current default.
      */
-    XML("xml", "Produces output in pretty-printed XML.");
+    XML("xml", "Produces output in pretty-printed XML."),
+    /**
+     * Official HTML5 stylesheet.
+     */
+    XHTML5("xhtml5", "Produces a HTML5 report");
     /**
      * The name of the style sheet. Must map to bundled resource xslt file
      */
@@ -70,27 +73,29 @@ public enum StyleSheets {
     }
 
     /**
-     * Gets the IOSupplier for a style sheet.
-     * @return an IOSupplier for the sheet.
+     * Gets the IODescriptor for a style sheet.
+     * @return an IODescriptor for the sheet.
      */
-    public IOSupplier<InputStream> getStyleSheet() {
-        return Objects.requireNonNull(StyleSheets.class.getClassLoader().getResource(format("org/apache/rat/%s.xsl", name)),
-                "missing stylesheet: " + name)::openStream;
+    public ReportConfiguration.IODescriptor<InputStream> getStyleSheet() {
+        URL url = StyleSheets.class.getClassLoader().getResource(format("org/apache/rat/%s.xsl", name));
+        Objects.requireNonNull(url, "missing stylesheet: " + name);
+        return new ReportConfiguration.IODescriptor<>(name, url::openStream);
     }
 
     /**
-     * Gets the IOSupplier for a style sheet.
+     * Gets the IODescriptor for a style sheet.
      * @param name the short name for or the path to a style sheet.
-     * @return the IOSupplier for the style sheet.
+     * @param workingDirectory the working directory to resolve the name against.
+     * @return the IODescriptor for the style sheet.
      */
-    public static IOSupplier<InputStream> getStyleSheet(final String name) {
+    public static ReportConfiguration.IODescriptor<InputStream> getStyleSheet(final String name, final DocumentName workingDirectory) {
         URL url = StyleSheets.class.getClassLoader().getResource(format("org/apache/rat/%s.xsl", name));
         if (url != null) {
-            return url::openStream;
+            return new ReportConfiguration.IODescriptor<>(name, url::openStream);
         }
-        Path p = Paths.get(name);
-        if (p.toFile().exists()) {
-            return () -> Files.newInputStream(p);
+        DocumentName xslt = workingDirectory.resolve(name);
+        if (xslt.asFile().exists()) {
+            return new ReportConfiguration.IODescriptor<>(xslt.toString(), () -> Files.newInputStream(xslt.asFile().toPath()));
         }
         throw new ConfigurationException(format("Stylesheet file '%s' not found", name));
     }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 7e7474b00..8a32b56fb 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -22,15 +22,22 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import org.apache.commons.lang3.NotImplementedException;
+import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
+import org.apache.rat.report.xml.writer.IXmlWriter;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.ExtendedIterator;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
 
 import static java.lang.String.format;
 
@@ -74,7 +81,13 @@ public ExclusionProcessor() {
         excludedCollections = new HashSet<>();
     }
 
-    /** Reset the {@link #lastMatcher} and {@link #lastMatcherBaseDir} to start again */
+    public Serde serde() {
+        return new Serde();
+    }
+
+    /**
+     * Reset the {@link #lastMatcher} and {@link #lastMatcherBaseDir} to start again
+     */
     private void resetLastMatcher() {
         lastMatcher = null;
         lastMatcherBaseDir = null;
@@ -337,4 +350,73 @@ private void extractPaths(final MatcherSet.Builder matcherBuilder) {
         }
     }
 
+    public class Serde {
+        public void serialize(final IXmlWriter writer) throws IOException {
+            writer.openElement("ExclusionProcessor");
+
+            for (String pattern : excludedPatterns) {
+                writer.openElement("excludedPattern").attribute("pattern", pattern).closeElement();
+            }
+            for (StandardCollection obj : excludedCollections) {
+                writer.openElement("excludedCollection").attribute("name", obj.name()).closeElement();
+            }
+            for (DocumentNameMatcher obj : excludedPaths) {
+                writer.openElement("excludedPath").attribute("name", obj.toString()).closeElement();
+            }
+
+            for (String pattern : includedPatterns) {
+                writer.openElement("includedPattern").attribute("pattern", pattern).closeElement();
+            }
+            for (StandardCollection obj : includedCollections) {
+                writer.openElement("includedCollection").attribute("name", obj.name()).closeElement();
+            }
+            for (DocumentNameMatcher obj : includedPaths) {
+                writer.openElement("includedPath").attribute("name", obj.toString()).closeElement();
+            }
+
+            for (StandardCollection obj : fileProcessors) {
+                writer.openElement("fileProcessor").attribute("name", obj.name()).closeElement();
+            }
+            writer.closeElement();
+
+        }
+
+        public void deserialize(final Node n) {
+            final NodeList children = n.getChildNodes();
+            for (int i = 0; i < children.getLength(); i++) {
+                Node child = children.item(i);
+                Map<String, String> attributes = XMLConfigurationReader.attributes(child);
+                StandardCollection collection;
+                switch (child.getNodeName()) {
+                    case "excludedPattern":
+                        excludedPatterns.add(attributes.get("pattern"));
+                        break;
+                    case "excludedCollection":
+                        collection = StandardCollection.valueOf(attributes.get("name"));
+                        excludedCollections.add(collection);
+                        break;
+                    case "excludedPath":
+                        excludedPaths.add(new DocumentNameMatcher(attributes.get("name"),
+                                (Predicate<DocumentName>) x -> {
+                                    throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
+                                }));
+                        break;
+                    case "includedPattern":
+                        includedPatterns.add(attributes.get("pattern"));
+                        break;
+                    case "includedCollection":
+                        collection = StandardCollection.valueOf(attributes.get("name"));
+                        includedCollections.add(collection);
+                        break;
+                    case "includedPath":
+                        excludedPaths.add(new DocumentNameMatcher(attributes.get("name"),
+                                (Predicate<DocumentName>) x -> {
+                                    throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
+                                }));
+                        break;
+                }
+
+            }
+        }
+    }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
index ac11bdd5a..04b9fbe45 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
@@ -173,7 +173,7 @@ public void read(final URI... uris) {
      * @param list the NodeList to process
      * @param consumer the consumer to apply to each node in the list.
      */
-    private void nodeListConsumer(final NodeList list, final Consumer<Node> consumer) {
+    public static void nodeListConsumer(final NodeList list, final Consumer<Node> consumer) {
         for (int i = 0; i < list.getLength(); i++) {
             consumer.accept(list.item(i));
         }
@@ -199,7 +199,7 @@ public void add(final Document newDoc) {
      * @param node The node to process
      * @return the map of attributes on the node.
      */
-    private Map<String, String> attributes(final Node node) {
+    public static Map<String, String> attributes(final Node node) {
         NamedNodeMap nnm = node.getAttributes();
         Map<String, String> result = new HashMap<>();
         for (int i = 0; i < nnm.getLength(); i++) {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
index 6fe00db5a..07f278918 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
@@ -20,13 +20,18 @@
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Optional;
+import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
+import org.apache.rat.ConfigurationException;
 import org.apache.rat.analysis.IHeaderMatcher;
 import org.apache.rat.analysis.IHeaders;
+import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log;
 import org.apache.rat.utils.ReportingSet;
 
@@ -121,6 +126,31 @@ public LicenseSetFactory(final SortedSet<ILicense> licenses) {
         licenses.forEach(l -> families.addIfNotPresent(l.getLicenseFamily()));
     }
 
+    public void validate() {
+        Log log = DefaultLog.getInstance();
+
+        // verify license definitions exist
+        if (getLicenses(LicenseFilter.ALL).isEmpty()) {
+            String msg = "At least one license must be defined";
+            log.error(msg);
+            throw new ConfigurationException(msg);
+        }
+
+        // verify that all approved license families exist
+        Set<String> exists = getLicenseFamilies(LicenseFilter.ALL)
+                .stream().map(ILicenseFamily::getFamilyCategory).collect(Collectors.toSet());
+        Set<String> approved = new HashSet<>(approvedLicenseCategories);
+        approved.removeIf(exists::contains);
+        approved.forEach(name -> log.warn(String.format("License category '%s' was approved but does not exist.", name)));
+
+        // verify that all approved licenses exist
+        exists = getLicenses(LicenseFilter.ALL)
+                .stream().map(ILicense::getId).collect(Collectors.toSet());
+        approved = new HashSet<>(approvedLicenseIds);
+        approved.removeIf(exists::contains);
+        approved.forEach(name -> log.warn(String.format("License '%s' was approved but does not exist.", name)));
+    }
+
     public void add(final LicenseSetFactory other) {
         this.families.addAll(other.families);
         this.licenses.addAll(other.licenses);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java b/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
index 2c108af6c..a92ba0599 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
@@ -33,5 +33,5 @@ public interface IReportable {
      * Returns the DocumentName for the reportable.
      * @return the DocumentName for the reportable.
      */
-    DocumentName getName();
+    DocumentName name();
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
index 62572916c..d47f2e5b7 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
@@ -19,14 +19,26 @@
 
 package org.apache.rat.report.claim;
 
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.rat.ConfigurationException;
 import org.apache.rat.api.Document;
+import org.apache.rat.configuration.XMLConfigurationReader;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.xml.sax.SAXException;
 
 /**
  * This class provides a numerical overview about
@@ -113,6 +125,9 @@ public String displayName() {
     /** Map of counter type to value */
     private final ConcurrentHashMap<ClaimStatistic.Counter, IntCounter> counterMap = new ConcurrentHashMap<>();
 
+    public Serde serde() {
+        return new Serde();
+    }
     /**
      * Converts null counter to 0.
      *
@@ -141,6 +156,15 @@ public void incCounter(final Counter counter, final int value) {
         counterMap.compute(counter, (k, v) -> v == null ? new IntCounter().increment(value) : v.increment(value));
     }
 
+    /**
+     * Increments the counts for the counter.
+     * @param counter the counter to increment.
+     * @param value the value to increment the counter by.
+     */
+    public void setCounter(final Counter counter, final int value) {
+        counterMap.put(counter, new IntCounter().increment(value));
+    }
+
     /**
      * Gets the counts for the Document.Type.
      * @param documentType the Document.Type to get the counter for.
@@ -288,5 +312,96 @@ public IntCounter increment(final int count) {
         public int value() {
             return value;
         }
+
+        @Override
+        public String toString() {
+            return String.valueOf(value);
+        }
+    }
+
+    /**
+     * Serialze and deserialze the claim Statistic.
+     */
+    public class Serde {
+
+        public void serialize(final Appendable appendable) throws IOException {
+            try (XmlWriter writer = new XmlWriter(appendable)) {
+                writer.startDocument().openElement("ClaimStatistic")
+                        .openElement("licenseNameMap");
+                for (Map.Entry<String, IntCounter> entry : licenseNameMap.entrySet()) {
+                    if (entry.getValue().value > 0) {
+                        writer.openElement("licenseName")
+                                .attribute("count", entry.getValue().toString())
+                                .attribute("name", entry.getKey()).closeElement();
+                    }
+                }
+                writer.closeElement()
+                        .openElement("licenseFamilyCategoryMap");
+                for (Map.Entry<String, IntCounter> entry : licenseFamilyCategoryMap.entrySet()) {
+                    if (entry.getValue().value > 0) {
+                        writer.openElement("familyCategory")
+                                .attribute("count", entry.getValue().toString())
+                                .attribute("name", entry.getKey()).closeElement();
+                    }
+                }
+                writer.closeElement()
+                        .openElement("documentTypeMap");
+                for (Map.Entry<Document.Type, IntCounter> entry : documentTypeMap.entrySet()) {
+                    if (entry.getValue().value > 0) {
+                        writer.openElement("documentType")
+                                .attribute("count", entry.getValue().toString())
+                                .attribute("name", entry.getKey().name()).closeElement();
+                    }
+                }
+                writer.closeElement()
+                        .openElement("counterMap");
+                for (Map.Entry<ClaimStatistic.Counter, IntCounter> entry : counterMap.entrySet()) {
+                    if (entry.getValue().value > 0) {
+                        writer.openElement("counter")
+                                .attribute("count", entry.getValue().toString())
+                                .attribute("name", entry.getKey().name()).closeElement();
+                    }
+                }
+                writer.closeElement();
+            }
+        }
+
+        public void deserialize(final IOSupplier<InputStream> inputStreamSupplier) throws IOException {
+            DocumentBuilder builder;
+            try {
+                builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+            } catch (ParserConfigurationException e) {
+                throw new ConfigurationException("Unable to create DOM builder", e);
+            }
+            org.w3c.dom.Document document;
+            try (InputStream stream = inputStreamSupplier.get()) {
+                document = builder.parse(stream);
+
+            } catch (SAXException e) {
+                throw new IOException("Unable to read input", e);
+            }
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("licenseName"), node -> {
+                Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+                incLicenseNameCount(attributes.get("name"), Integer.parseInt(attributes.get("count")));
+            });
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("familyCategory"), node -> {
+                Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+                incLicenseCategoryCount(attributes.get("name"), Integer.parseInt(attributes.get("count")));
+            });
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("documentType"), node -> {
+                Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+                Document.Type type = Document.Type.valueOf(attributes.get("name"));
+                incCounter(type, Integer.parseInt(attributes.get("count")));
+            });
+
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("counter"), node -> {
+                Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+                Counter type = Counter.valueOf(attributes.get("name"));
+                setCounter(type, Integer.parseInt(attributes.get("count")));
+            });
+        }
     }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
index 056090858..1898c4e84 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
@@ -72,7 +72,7 @@ private FileDocument createDocument(final String unixFileName) {
     @Override
     public void run(final RatReport report) throws RatException {
         DefaultLog.getInstance().debug(String.format("Reading file name: %s due to option %s", source, Arg.SOURCE.option()));
-        DocumentName sourceName = getName();
+        DocumentName sourceName = name();
         try (Reader reader = source.reader()) {
             for (String docName : IOUtils.readLines(reader)) {
                 try {
@@ -93,7 +93,7 @@ public void run(final RatReport report) throws RatException {
     }
 
     @Override
-    public DocumentName getName() {
+    public DocumentName name() {
         return source.getName();
     }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
index b028b9c68..8df62905e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
@@ -61,13 +61,13 @@ public void run(final RatReport report) {
             try {
                 reportable.run(report);
             } catch (RatException e) {
-                DefaultLog.getInstance().error("Error processing " + reportable.getName(), e);
+                DefaultLog.getInstance().error("Error processing " + reportable.name(), e);
             }
         }
     }
 
     @Override
-    public DocumentName getName() {
+    public DocumentName name() {
         return documentName;
     }
 
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
index 5651f7ab9..f0e6d7bd4 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
@@ -48,7 +48,7 @@ protected Document getDocument() {
     }
 
     @Override
-    public DocumentName getName() {
+    public DocumentName name() {
         return document.getName();
     }
 }
diff --git a/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl b/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl
new file mode 100644
index 000000000..b15224605
--- /dev/null
+++ b/apache-rat-core/src/main/resources/org/apache/rat/xhtml5.xsl
@@ -0,0 +1,354 @@
+<xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
+
+    <!--***********************************************************
+     *
+     * Licensed to the Apache Software Foundation (ASF) under one
+     * or more contributor license agreements.  See the NOTICE file
+     * distributed with this work for additional information
+     * regarding copyright ownership.  The ASF licenses this file
+     * to you under the Apache License, Version 2.0 (the
+     * "License"); you may not use this file except in compliance
+     * with the License.  You may obtain a copy of the License at
+     *
+     *   http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing,
+     * software distributed under the License is distributed on an
+     * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+     * KIND, either express or implied.  See the License for the
+     * specific language governing permissions and limitations
+     * under the License.
+     *
+     ***********************************************************-->
+
+    <!-- This style sheet converts any rat-report.xml file.  -->
+
+    <xsl:output method='xml'/>
+
+    <xsl:variable name='notapproved'>&#10071;</xsl:variable>
+    <xsl:variable name="archive"><span style="font-size:x-large;">&#128476;</span></xsl:variable>
+    <xsl:variable name="binary"><span style="padding-left:4px;">&#128288;</span></xsl:variable>
+    <xsl:variable name="ignored"><span style="padding-left:4px;">&#128683;</span></xsl:variable>
+    <xsl:variable name="notice"><span style="font-size:x-large;padding-left:4px;">&#8505;</span></xsl:variable>
+    <xsl:variable name="standard"><span style="padding-left:4px;">&#9989;</span></xsl:variable>
+    <xsl:variable name="unknown">&#10067;</xsl:variable>
+    <xsl:variable name="directory"><span style="padding-left:4px;background-color: #00000087;">&#128194;</span></xsl:variable>
+
+    <xsl:template match="/">
+        <html>
+            <head>
+                <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
+                <style type="text/css">
+                    <xsl:comment>
+                        body {margin-top: 0px;background-color: #F9F7ED;}
+
+                        h1 {color:red;}
+                        h2 {color:blue;}
+                        h3 {color:blueviolet;}
+                        h4 {color:green;}
+                        div.section {padding-left:5em;}
+                        div.subsection {padding-left:5em;}
+
+                        /* Table Design */
+                        table,tr,td {font-weight:bold;border:1px solid #000;}
+                        table {min-width: 50%;}
+                        caption {color:blue;text-align:left;}
+
+                        .document-name {font-size:larger;}
+                        .document-mediatype {float: left;}
+                        .document-encoding {padding-left: 2em;}
+                        .license-entry {padding-left: 1em;}
+                        .license-id {padding-left: 2em;}
+                        .license-family {padding-left: 1em;}
+                    </xsl:comment>
+                </style>
+            </head>
+            <body>
+                <xsl:apply-templates />
+            </body>
+        </html>
+    </xsl:template>
+
+    <xsl:template match="rat-report">
+
+        <h1>Rat Report</h1>
+
+        <xsl:call-template name="summary" />
+
+
+        <xsl:if test="descendant::resource[license/@approval='false']">
+            <xsl:call-template name="unapproved-files" />
+        </xsl:if>
+
+        <xsl:if test="descendant::resource[@type='ARCHIVE']">
+            <xsl:call-template name="archives" />
+        </xsl:if>
+
+        <h2>Detail</h2>
+
+        <p>
+            Documents with unapproved licenses will start with a <xsl:value-of select="$notapproved"/>
+            The first character on the next line identifies the document type.
+        </p>
+        <table id="rat-reports symbols" cellspacing="0"
+        summary="Symbols used in this RAT report">
+        <caption>
+            Symbols used in this RAT report
+        </caption>
+            <tr>
+                <th>Symbol</th>
+                <th>Type</th>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$archive"/></td>
+                <td>Archive file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$binary"/></td>
+                <td>Binary file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$ignored"/></td>
+                <td>Ignored file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$notice"/></td>
+                <td>Notice file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$standard"/></td>
+                <td>Standard file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$unknown"/></td>
+                <td>Unknown file</td>
+            </tr>
+            <tr>
+                <td><xsl:value-of select="$directory"/></td>
+                <td>Directory</td>
+            </tr>
+        </table>
+
+        <table id="rat-reports resources" cellspacing="0"
+               summary="Resources discovered in this RAT report">
+            <caption>
+                Resources discovered in this RAT report
+            </caption>
+            <xsl:for-each select='descendant::resource'>
+                <tr>
+                    <td>
+                        <xsl:if test="@isDirectory = 'true'"><xsl:value-of select="$directory"/></xsl:if>
+                        <xsl:if test="license/@approval = 'false'"><xsl:value-of select="$notapproved"/></xsl:if>
+                        <xsl:choose>
+                            <xsl:when test="substring(@type, 1, 1) = 'A'"><xsl:value-of select="$archive"/></xsl:when>
+                            <xsl:when test="substring(@type, 1, 1) = 'B'"><xsl:value-of select="$binary"/></xsl:when>
+                            <xsl:when test="substring(@type, 1, 1) = 'I'"><xsl:value-of select="$ignored"/></xsl:when>
+                            <xsl:when test="substring(@type, 1, 1) = 'N'"><xsl:value-of select="$notice"/></xsl:when>
+                            <xsl:when test="substring(@type, 1, 1) = 'S'"><xsl:value-of select="$standard"/></xsl:when>
+                            <xsl:when test="substring(@type, 1, 1) = 'U'"><xsl:value-of select="$unknown"/></xsl:when>
+                        </xsl:choose>
+                    </td>
+                    <td>
+                        <div class="document-entry">
+                            <span class="document-name"><xsl:value-of select='@name'/></span>
+                            <div class="document-meta">
+                                <span class="document-mediatype"><xsl:value-of select="@mediaType"/></span>
+                                <span class="document-encoding"><xsl:value-of select="@encoding"/></span>
+                            </div>
+                        </div>
+                        <xsl:for-each select='descendant::license'>
+                            <div class="license-entry">
+                                <div>
+                                    <xsl:if test="@approval = 'false'">
+                                        <span class='approval-icon'><xsl:value-of select="$notapproved"/></span>
+                                    </xsl:if>
+                                    <span class="license-name"><xsl:value-of select="@name"/></span>
+                                </div>
+                                <span class="license-id">ID:
+                                    <xsl:choose>
+                                        <xsl:when test="@id = '?????'">UUID</xsl:when>
+                                        <xsl:otherwise><xsl:value-of select="@id"/></xsl:otherwise>
+                                    </xsl:choose>
+                                </span>
+                                <span class="license-family">Family:
+                                    <xsl:choose>
+                                        <xsl:when test="@family = '?????'">Unknown</xsl:when>
+                                        <xsl:otherwise><xsl:value-of select="@family"/></xsl:otherwise>
+                                    </xsl:choose>
+                                </span>
+                            </div>
+                        </xsl:for-each>
+                    </td>
+                </tr>
+            </xsl:for-each>
+        </table>
+    </xsl:template>
+
+    <xsl:template name="summary">
+        <h2>Summary</h2>
+
+        <div class="section">
+            <p>Generated at <xsl:value-of select='@timestamp' />  by
+                <xsl:value-of select='concat(version/@product, " ", rat-report/version/@version, " (", rat-report/version/@vendor, ")")'/>
+            </p>
+
+            <table id="rat-reports summary statistics" cellspacing="0"
+                   summary="A  summary of statistics from this RAT report">
+                <caption>
+                    Table 1: A summary of statistics from this RAT report.
+                </caption>
+                <tr>
+                    <th colspan="1">Name:</th>
+                    <th colspan="1">Count:</th>
+                    <th colspan="1">Description:</th>
+                </tr>
+                <xsl:for-each select='descendant::statistic'>
+                    <tr>
+                       <td>
+                            <xsl:if test='@approval="false"'>
+                                <span class='approval-icon'><xsl:value-of select="$notapproved"/></span>
+                            </xsl:if>
+                            <xsl:choose>
+                                <xsl:when test="@name = '?????'">Unknown</xsl:when>
+                                <xsl:otherwise><xsl:value-of select="@name"/></xsl:otherwise>
+                            </xsl:choose>
+                        </td>
+                        <td><xsl:value-of select='@count'/></td>
+                        <td><xsl:value-of select='@description'/></td>
+                    </tr>
+                </xsl:for-each>
+            </table>
+
+            <h3>License Statistics</h3>
+            <div class="subsection">
+                <h4>Categories</h4>
+                <div class="subsection">
+                    <table id="rat-reports summary license-categories" cellspacing="0"
+                           summary="A summary of license categories found in this RAT report">
+                        <caption>
+                            Table 2: License categories found in this RAT report.
+                        </caption>
+                        <tr>
+                            <th colspan="1">Name:</th>
+                            <th colspan="1">Count:</th>
+                        </tr>
+
+                        <xsl:for-each select='descendant::licenseCategory'>
+                            <tr>
+                                <td>
+                                    <xsl:if test='@approved="false"'>
+                                        <span class='approval-icon'><xsl:value-of select="$notapproved"/></span>
+                                    </xsl:if>
+                                    <xsl:choose>
+                                        <xsl:when test="@name = '?????'">Unknown</xsl:when>
+                                        <xsl:otherwise><xsl:value-of select="@name"/></xsl:otherwise>
+                                    </xsl:choose>
+                                </td>
+                                <td><xsl:value-of select='@count'/></td>
+                            </tr>
+                        </xsl:for-each>
+                    </table>
+                </div>
+
+                <h4>Licenses</h4>
+                <div class="subsection">
+                    <table id="rat-reports summary licenses" cellspacing="0"
+                           summary="Licenses found in this RAT report">
+                        <caption>
+                            Table 3: Licenses found in this RAT report.
+                        </caption>
+                        <tr>
+                            <td colspan="1">Name:</td>
+                            <td colspan="1">Count:</td>
+                        </tr>
+
+                        <xsl:for-each select='descendant::licenseName'>
+                            <tr>
+                                <td>
+                                    <xsl:if test='@approved="false"'>
+                                        <span class='approval-icon'><xsl:value-of select="$notapproved"/></span>
+                                    </xsl:if>
+                                    <xsl:choose>
+                                        <xsl:when test="@name = '?????'">Unknown</xsl:when>
+                                        <xsl:otherwise><xsl:value-of select="@name"/></xsl:otherwise>
+                                    </xsl:choose>
+                                </td>
+                                <td><xsl:value-of select='@count'/></td>
+                            </tr>
+                        </xsl:for-each>
+                    </table>
+                </div>
+            </div>
+
+            <h3>Document types</h3>
+            <div class="subsection">
+                <table id="rat-reports summary document-types" cellspacing="0"
+                       summary="Document types found in this RAT report">
+                    <caption>
+                        Table 4: Document types found in this RAT report.
+                    </caption>
+                    <tr>
+                        <th colspan="1">Name:</th>
+                        <th colspan="1">Count:</th>
+                    </tr>
+
+                    <xsl:for-each select='descendant::documentType'>
+                        <tr>
+                            <td><xsl:value-of select="@name"/></td>
+                            <td><xsl:value-of select="@count"/></td>
+                        </tr>
+                    </xsl:for-each>
+                </table>
+            </div>
+        </div>
+    </xsl:template>
+
+    <xsl:template name="unapproved-files">
+        <h2>Files with unapproved licenses</h2>
+
+        <ul class="unapproved-licenses">
+            <xsl:for-each select='descendant::resource[license/@approval="false"]'>
+                <li class="document-name"><xsl:value-of select='@name'/></li>
+            </xsl:for-each>
+        </ul>
+    </xsl:template>
+
+    <xsl:template name="archives">
+        <h2>Archives</h2>
+        <ul>
+            <xsl:for-each select='descendant::resource[@type="ARCHIVE"]'>
+                <li class="document-name"><xsl:value-of select='@name'/></li>
+            </xsl:for-each>
+        </ul>
+    </xsl:template>
+
+
+    <xsl:template name="license">
+        <xsl:param name="family"/>
+        <xsl:param name="id"/>
+        <xsl:param name="name"/>
+        <xsl:param name="approval"/>
+
+        <tr>
+            <td> </td>
+            <td>
+                <table>
+                    <tr>
+                        <xsl:if test="$approval = 'false'">
+                            <xsl:value-of select="$notapproved"/>
+                        </xsl:if>
+                    </tr>
+                    <tr>
+                        <div class="document-license">
+                            <span class="license-name"><xsl:value-of select="$name"/></span>
+                            <div class="documment-license-meta">
+                                <span class="id"><xsl:value-of select="$id"/></span>
+                                <span class="family"><xsl:value-of select="$family"/></span>
+                            </div>
+                        </div>
+                    </tr>
+                </table>
+            </td>
+        </tr>
+    </xsl:template>
+</xsl:transform>
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
index 238bc69c1..86f58c325 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
@@ -235,7 +235,7 @@ public void getReportableTest(String fName) throws IOException {
         ReportConfiguration config = OptionCollection.parseCommands(testPath.toFile(), new String[]{fName}, o -> fail("Help called"), false);
         IReportable reportable = OptionCollection.getReportable(base, config);
         assertThat(reportable).as(() -> format("'%s' returned null", fName)).isNotNull();
-        assertThat(reportable.getName().getName()).isEqualTo(expected);
+        assertThat(reportable.name().getName()).isEqualTo(expected);
     }
 
     @Test
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
index 69af88b2b..f29c622ea 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
@@ -39,6 +39,7 @@
 import java.util.List;
 import java.util.SortedSet;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import org.apache.commons.io.filefilter.DirectoryFileFilter;
 import org.apache.commons.io.output.CloseShieldOutputStream;
@@ -56,6 +57,7 @@
 import org.apache.rat.testhelpers.TestingLicense;
 import org.apache.rat.testhelpers.TestingMatcher;
 import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.Log;
 import org.apache.rat.utils.Log.Level;
 import org.apache.rat.utils.ReportingSet.Options;
 import org.junit.jupiter.api.AfterEach;
@@ -456,7 +458,7 @@ public void outputTest() throws IOException {
         assertThat(underTest.getWriter()).isNotNull();
 
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
-        underTest.setOut(() -> stream);
+        underTest.setOut(new ReportConfiguration.IODescriptor<>("outputTest", () -> stream));
         assertThat(underTest.getOutput().get()).isEqualTo(stream);
         PrintWriter writer = underTest.getWriter().get();
         assertThat(writer).isNotNull();
@@ -480,9 +482,9 @@ public void stylesheetTest() throws IOException, URISyntaxException {
         URL url = this.getClass().getResource("ReportConfigurationTestFile");
         assertThat(url).isNotNull();
 
-        assertThat(underTest.getStyleSheet()).isNull();
+        assertThat(underTest.getStyleSheetDescriptor()).isNull();
         InputStream stream = mock(InputStream.class);
-        underTest.setStyleSheet(() -> stream);
+        underTest.setStyleSheet(new ReportConfiguration.IODescriptor<>("stylesheetTest", () -> stream));
         assertThat(underTest.getStyleSheet().get()).isEqualTo(stream);
 
         File file = mock(File.class);
@@ -515,32 +517,37 @@ public void testFlags() {
 
     @Test
     public void testValidate() {
-        final StringBuilder sb = new StringBuilder();
+        TestingLog testLog = new TestingLog();
+        Log oldLog = DefaultLog.getInstance();
+        try {
+            DefaultLog.setInstance(testLog);
+
         String msg = "At least one source must be specified";
-        assertThatThrownBy(() -> underTest.validate(sb::append)).isExactlyInstanceOf(ConfigurationException.class)
+            assertThatThrownBy(underTest::validate).isExactlyInstanceOf(ConfigurationException.class)
                 .hasMessageContaining(msg);
-        assertThat(sb.toString()).isEqualTo(msg);
+            testLog.assertContains(msg);
+            testLog.clear();
 
 
-        sb.setLength(0);
-        msg = "You must specify at least one license";
+            msg = "At least one license must be defined";
         underTest.addSource(mock(IReportable.class));
 
-        assertThatThrownBy(() -> underTest.validate(sb::append)).isExactlyInstanceOf(ConfigurationException.class)
+            assertThatThrownBy(underTest::validate).isExactlyInstanceOf(ConfigurationException.class)
                 .hasMessageContaining(msg);
-        assertThat(sb.toString()).isEqualTo(msg);
+            testLog.assertContains(msg);
 
-        sb.setLength(0);
         underTest.addLicense(testingLicense("valid", "Validation testing license"));
-        underTest.validate(sb::append);
-        assertThat(sb.length()).isEqualTo(0);
+            underTest.validate();
+        } finally {
+            DefaultLog.setInstance(oldLog);
+        }
     }
     
     @Test
     public void testSetOut() throws IOException {
         ReportConfiguration config = new ReportConfiguration();
         try (OutputStreamInterceptor osi = new OutputStreamInterceptor()) {
-            config.setOut(() -> osi);
+            config.setOut(new ReportConfiguration.IODescriptor<>("testSetOut", () -> osi));
             assertThat(osi.closeCount).isEqualTo(0);
             try (OutputStream os = config.getOutput().get()) {
                 assertThat(os).isNotNull();
@@ -563,16 +570,18 @@ public void logFamilyCollisionTest() {
        
         // verify default collision logs WARNING
         underTest.addFamily(ILicenseFamily.builder().setLicenseFamilyCategory("CAT").setLicenseFamilyName("name2"));
-        assertThat(log.getCaptured().contains("WARN")).as("default value not WARN").isTrue();
-        assertThat(log.getCaptured().contains("CAT")).as("'CAT' not found").isTrue();
+        assertThat(log.getCaptured()).contains("WARN").contains("CAT");
         
         // verify level setting works.
         for (Level l : Level.values()) {
           log.clear();
           underTest.logFamilyCollisions(l);
           underTest.addFamily(ILicenseFamily.builder().setLicenseFamilyCategory("CAT").setLicenseFamilyName("name2"));
-          assertThat(log.getCaptured().contains("CAT")).as("'CAT' not found").isTrue();
-          assertThat(log.getCaptured().contains(l.name())).as("logging not set to "+l).isTrue();
+          if (DefaultLog.getInstance().isEnabled(l)) {
+              assertThat(log.getCaptured()).contains("CAT").contains(l.name());
+          } else {
+              assertThat(log.getCaptured()).doesNotContain("CAT").doesNotContain(l.name());
+          }
         }
     }
     
@@ -662,51 +671,52 @@ public void licenseDuplicateOptionsTest() {
                 .isExactlyInstanceOf(IllegalArgumentException.class);
     }
 
-    /**
-     * Validates that the configuration contains the default approved licenses.
-     * @param config The configuration to test.
-     */
-    public static void validateDefaultApprovedLicenses(ReportConfiguration config) {
-        validateDefaultApprovedLicenses(config, 0);
-    }
     
     /**
      * Validates that the configuration contains the default approved licenses.
      * @param config The configuration to test.
      */
-    public static void validateDefaultApprovedLicenses(ReportConfiguration config, int additionalIdCount) {
-        assertThat(config.getLicenseCategories(LicenseFilter.APPROVED)).hasSize(XMLConfigurationReaderTest.APPROVED_IDS.length + additionalIdCount);
-        for (String s : XMLConfigurationReaderTest.APPROVED_IDS) {
-            assertThat(config.getLicenseCategories(LicenseFilter.APPROVED)).contains(ILicenseFamily.makeCategory(s));
+    public static void validateDefaultApprovedLicenses(ReportConfiguration config, String... additionalIds) {
+        validateLicenses(config, Arrays.asList(additionalIds), LicenseFilter.APPROVED, XMLConfigurationReaderTest.APPROVED_LICENSES);
         }
+
+    /**
+     * Validates that the configuration contains all the default licenses along with any addiitonal licenses
+     * @param config the configuration to test.
+     * @param additionalLicenses Additional licence IDs that are expected.
+     */
+    public static void validateDefaultLicenses(ReportConfiguration config, String...additionalLicenses) {
+        validateLicenses(config, Arrays.asList(additionalLicenses), LicenseFilter.ALL, XMLConfigurationReaderTest.EXPECTED_LICENSES);
     }
 
+    private static void validateLicenses(ReportConfiguration config, List<String> additionalIds, LicenseFilter filter, String[] approvedIds) {
+        List<String> expected = new ArrayList<>(Arrays.asList(approvedIds));
+        expected.addAll(additionalIds);
+        assertThat(config.getLicenses(filter).stream().map(ILicense::getId).collect(Collectors.toSet())).containsExactlyInAnyOrderElementsOf(expected);
+    }
+
+
     /**
      * Validates that the configuration contains the default license families.
      * @param config the configuration to test.
      */
     public static void validateDefaultLicenseFamilies(ReportConfiguration config, String...additionalIds) {
-        assertThat(config.getLicenseFamilies(LicenseFilter.ALL)).hasSize(XMLConfigurationReaderTest.EXPECTED_IDS.length + additionalIds.length);
-        List<String> expected = new ArrayList<>();
-        expected.addAll(Arrays.asList(XMLConfigurationReaderTest.EXPECTED_IDS));
-        expected.addAll(Arrays.asList(additionalIds));
-        for (ILicenseFamily family : config.getLicenseFamilies(LicenseFilter.ALL)) {
-            assertThat(expected).contains(family.getFamilyCategory().trim());
-        }
+        validateLicenseFamilies(config, Arrays.asList(additionalIds), LicenseFilter.ALL, XMLConfigurationReaderTest.EXPECTED_IDS);
     }
 
     /**
-     * Validates that the configuration contains the default licenses.
+     * Validates that the configuration contains the default license families.
      * @param config the configuration to test.
      */
-    public static void validateDefaultLicenses(ReportConfiguration config, String...additionalLicenses) {
-        assertThat(config.getLicenses(LicenseFilter.ALL)).hasSize(XMLConfigurationReaderTest.EXPECTED_LICENSES.length + additionalLicenses.length);
-        List<String> expected = new ArrayList<>();
-        expected.addAll(Arrays.asList(XMLConfigurationReaderTest.EXPECTED_LICENSES));
-        expected.addAll(Arrays.asList(additionalLicenses));
-        for (ILicense license : config.getLicenses(LicenseFilter.ALL)) {
-            assertThat(expected).contains(license.getId());
+    public static void validateDefaultApprovedLicenseFamilies(ReportConfiguration config, String...additionalIds) {
+        validateLicenseFamilies(config, Arrays.asList(additionalIds), LicenseFilter.APPROVED, XMLConfigurationReaderTest.APPROVED_IDS);
         }
+
+    private static void validateLicenseFamilies(ReportConfiguration config, List<String> additionalIds, LicenseFilter filter, String[] approvedIds) {
+        List<String> expected = new ArrayList<>(Arrays.asList(approvedIds));
+        expected.addAll(additionalIds);
+        assertThat(config.getLicenseFamilies(filter).stream().map(lf -> lf.getFamilyCategory().trim())
+                .collect(Collectors.toSet())).containsExactlyInAnyOrderElementsOf(expected);
     }
     
     /**
@@ -719,9 +729,10 @@ public static void validateDefault(ReportConfiguration config) {
         assertThat(config.getCopyrightMessage()).isNull();
         assertThat(config.getStyleSheet()).withFailMessage("Stylesheet should not be null").isNotNull();
 
-        validateDefaultApprovedLicenses(config);
         validateDefaultLicenseFamilies(config);
+        validateDefaultApprovedLicenseFamilies(config);
         validateDefaultLicenses(config);
+        validateDefaultApprovedLicenses(config);
     }
 
     /**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index b6167cbf7..72d01010c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -133,9 +133,9 @@ private void validateNoArgSetup() throws IOException, RatException {
         try {
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
+            Reporter.Output output = reporter.execute();
             ClaimValidator validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).isEmpty();
+            assertThat(validator.listIssues(output.getStatistic())).isEmpty();
         } finally {
             DefaultLog.setInstance(null);
         }
@@ -160,8 +160,8 @@ private void editLicenseTest(final Option option) {
             FileUtils.delete(resultFile);
 
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic).isNotNull();
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic()).isNotNull();
             String contents = String.join("\n", IOUtils.readLines(new FileReader(testFile)));
             assertThat(contents).isEqualTo("class NoLicense {}");
             assertThat(resultFile).exists();
@@ -214,9 +214,9 @@ private void execLicensesDeniedTest(final Option option, final String[] args) {
 
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
+            Reporter.Output output = reporter.execute();
             ClaimValidator validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+            assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
         });
     }
 
@@ -247,9 +247,9 @@ private void noDefaultsTest(final Option option) {
                 reporter.execute();
                 fail("Should have thrown exception");
             } catch (RatException e) {
-                ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
+               // ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
                 ClaimValidator validator = config.getClaimValidator();
-                assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
+              //  assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
             }
         });
     }
@@ -276,16 +276,16 @@ protected void counterMaxTest() {
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
+            Reporter.Output output = reporter.execute();
             ClaimValidator validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+            assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
 
             arg[0] = "Unapproved:1";
             config = generateConfig(ImmutablePair.of(option, arg));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
+            output  = reporter.execute();
             validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).isEmpty();
+            assertThat(validator.listIssues(output.getStatistic())).isEmpty();
         });
     }
 
@@ -301,16 +301,16 @@ protected void counterMinTest() {
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
+            Reporter.Output output = reporter.execute();
             ClaimValidator validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+            assertThat(validator.listIssues(output.getStatistic())).containsExactly("UNAPPROVED");
 
             arg[0] = "Unapproved:1";
             config = generateConfig(ImmutablePair.of(option, arg));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
+            output = reporter.execute();
             validator = config.getClaimValidator();
-            assertThat(validator.listIssues(claimStatistic)).isEmpty();
+            assertThat(validator.listIssues(output.getStatistic())).isEmpty();
         });
     }
 
@@ -329,16 +329,16 @@ private void execExcludeTest(final Option option, final String[] args, final boo
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
 
             // filter out source
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+            output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
         });
     }
 
@@ -381,16 +381,16 @@ protected void inputExcludeSizeTest() {
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
 
             // filter out source
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
+            output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
         });
     }
 
@@ -415,15 +415,15 @@ protected void inputExcludeStdTest() {
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(4);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(4);
 
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
+            output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
         });
     }
 
@@ -471,16 +471,16 @@ protected void inputExcludeParsedScmTest() {
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(11);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(11);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
 
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(8);
+            output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(8);
         });
     }
 
@@ -499,25 +499,25 @@ private void execIncludeTest(final Option option, final String[] args, boolean a
 
             ReportConfiguration config = generateConfig(Collections.emptyList());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
 
             // verify exclude removes most files.
             config = generateConfig(ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
 
             // verify include pust them back
             config = generateConfig(ImmutablePair.of(option, args), ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 2 : 1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 2 : 1);
         });
     }
 
@@ -569,15 +569,15 @@ protected void inputIncludeStdTest() {
 
             ReportConfiguration config = generateConfig(Collections.singletonList(excludes));
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(5);
 
             config = generateConfig(excludes, ImmutablePair.of(option, args));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(7);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(7);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(1);
         });
     }
 
@@ -594,15 +594,15 @@ protected void inputSourceTest() {
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
 
             config = generateConfig(ImmutablePair.of(option, new String[]{inputFile.getAbsolutePath()}));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
         });
     }
 
@@ -624,18 +624,18 @@ private void execLicenseFamiliesApprovedTest(final Option option, final String[]
 
             ReportConfiguration config = addCatzLicense(generateConfig());
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
+            Reporter.Output output = reporter.execute();
 
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             config = addCatzLicense(generateConfig(arg1));
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
         });
     }
 
@@ -664,17 +664,17 @@ private void execLicenseFamiliesDeniedTest(final Option option, final String[] a
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
         });
     }
 
@@ -705,26 +705,26 @@ private void configTest(final Option option) {
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
 
             Pair<Option, String[]> arg2 = ImmutablePair.of(Arg.CONFIGURATION_NO_DEFAULTS.find("configuration-no-defaults"), null);
 
             config = generateConfig(arg1, arg2);
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
         });
     }
@@ -751,17 +751,17 @@ protected void execLicensesApprovedTest(final Option option, String[] args) {
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
         });
     }
 
@@ -795,17 +795,17 @@ protected void scanHiddenDirectoriesTest() {
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            Reporter.Output output = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
-            claimStatistic = reporter.execute();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            output  = reporter.execute();
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
         });
     }
 
@@ -819,10 +819,11 @@ private void outTest(final Option option) {
 
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.output();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            Reporter.Output output = reporter.execute();
+            output.format(config);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
 
             String actualText = TextUtils.readFile(outFile);
             TextUtils.assertContainsExactly(1, "Apache License 2.0: 1 ", actualText);
@@ -859,10 +860,11 @@ private void styleSheetTest(final Option option) {
                 args[0] = sheet.arg();
                 ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
                 Reporter reporter = new Reporter(config);
-                ClaimStatistic claimStatistic = reporter.output();
-                assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-                assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
-                assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+                Reporter.Output output  = reporter.execute();
+                output.format(config);
+                assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+                assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+                assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
                 String actualText = baos.toString(StandardCharsets.UTF_8);
                 switch (sheet) {
@@ -880,6 +882,9 @@ private void styleSheetTest(final Option option) {
                     case UNAPPROVED_LICENSES:
                         TextUtils.assertContainsExactly(1, "Files with unapproved licenses:" + System.lineSeparator() + "  /stylesheet", actualText);
                         break;
+                    case XHTML5:
+                        TextUtils.assertPatternInTarget("<td>Approved<\\/td>\\s+<td>\\d+<\\/td>\\s+<td>A count of approved licenses.<\\/td>", actualText);
+                        break;
                     default:
                         fail("No test for stylesheet " + sheet);
                         break;
@@ -889,10 +894,11 @@ private void styleSheetTest(final Option option) {
             args[0] = file.getAbsolutePath();
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.output();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            Reporter.Output output  = reporter.execute();
+            output.format(config);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             String actualText = baos.toString(StandardCharsets.UTF_8);
             TextUtils.assertContainsExactly(1, "Hello world", actualText);
@@ -931,15 +937,16 @@ protected void xmlTest() {
 
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, null));
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.output();
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
+            Reporter.Output output  = reporter.execute();
+            output.format(config);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             String actualText = baos.toString(StandardCharsets.UTF_8);
             TextUtils.assertContainsExactly(1, "<resource encoding=\"ISO-8859-1\" mediaType=\"text/plain\" name=\"/stylesheet\" type=\"STANDARD\">", actualText);
 
-            try (InputStream expected = StyleSheets.getStyleSheet("xml").get();
+            try (InputStream expected = StyleSheets.getStyleSheet("xml", null).ioSupplier().get();
                  InputStream actual = config.getStyleSheet().get()) {
                 assertThat(IOUtils.contentEquals(expected, actual)).as("'xml' does not match").isTrue();
             }
@@ -962,12 +969,12 @@ protected void logLevelTest() {
 
             ReportConfiguration config = generateConfig();
             Reporter reporter = new Reporter(config);
-            reporter.output();
+            reporter.execute();
             TextUtils.assertNotContains("DEBUG", baos.toString(StandardCharsets.UTF_8));
 
             config = generateConfig(ImmutablePair.of(option, new String[]{"debug"}));
             reporter = new Reporter(config);
-            reporter.output();
+            reporter.execute();
             TextUtils.assertContains("DEBUG", baos.toString(StandardCharsets.UTF_8));
         } catch (IOException | RatException e) {
             fail(e.getMessage(), e);
@@ -983,16 +990,15 @@ private void listLicenses(final Option option) {
 
         assertDoesNotThrow(() -> {
             configureSourceDir(option);
-            File outFile = new File(sourceDir, "out.xml");
-            FileUtils.delete(outFile);
-            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
-            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
+//            File outFile = new File(sourceDir, "out.xml");
+//            FileUtils.delete(outFile);
+//            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
+//            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
             for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
                 args[0] = filter.name();
-                ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
+                ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
                 Reporter reporter = new Reporter(config);
-                reporter.output();
-                Document document = XmlUtils.toDom(new FileInputStream(outFile));
+                Document document = reporter.execute().getDocument();
                 switch (filter) {
                     case ALL:
                         XmlUtils.assertIsPresent(filter.name(), document, xPath, "/rat-report/rat-config/licenses/license[@id='AL2.0']");
@@ -1029,16 +1035,16 @@ private void listFamilies(final Option option) {
 
         assertDoesNotThrow(() -> {
             configureSourceDir(option);
-            File outFile = new File(sourceDir, "out.xml");
-            FileUtils.delete(outFile);
-            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
-            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
+//            File outFile = new File(sourceDir, "out.xml");
+//            FileUtils.delete(outFile);
+//            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
+//            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
             for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
                 args[0] = filter.name();
-                ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
+                ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
                 Reporter reporter = new Reporter(config);
-                reporter.output();
-                Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+                Reporter.Output output = reporter.execute();
+                Document document = output.getDocument();
                 switch (filter) {
                     case ALL:
                         XmlUtils.assertIsPresent(filter.name(), document, xPath, "/rat-report/rat-config/families/family[@id='AL']");
@@ -1090,9 +1096,8 @@ private void archiveTest(final Option option) {
                 args[0] = proc.name();
                 ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
                 Reporter reporter = new Reporter(config);
-                reporter.output();
 
-                Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+                Document document = reporter.execute().getDocument();
                 XmlUtils.assertIsPresent(proc.name(), document, xPath, "/rat-report/resource[@name='/dummy.jar']");
                 switch (proc) {
                     case ABSENCE:
@@ -1140,9 +1145,9 @@ private void standardTest(final Option option) {
                 args[0] = proc.name();
                 ReportConfiguration config = generateConfig(outputFile, stylesheet, ImmutablePair.of(option, args));
                 Reporter reporter = new Reporter(config);
-                reporter.output();
+                Reporter.Output output = reporter.execute();
 
-                Document document = XmlUtils.toDom(Files.newInputStream(outFile.toPath()));
+                Document document = output.getDocument();
                 XmlUtils.assertIsPresent(proc.name(), document, xPath, testDoc);
                 XmlUtils.assertIsPresent(proc.name(), document, xPath, missingDoc);
 
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
index 2694b4c91..4f52a31a5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsTest.java
@@ -78,14 +78,14 @@ void testRat362() {
             FileUtils.writeFile(testDir, "foo.md");
             ReportConfiguration config = OptionCollection.parseCommands(testDir, args, o -> fail("Help called"), true);
             Reporter reporter = new Reporter(config);
-            ClaimStatistic claimStatistic = reporter.execute();
-            XmlUtils.printDocument(System.out, reporter.getDocument());
+            Reporter.Output output = reporter.execute();
+            XmlUtils.printDocument(System.out, output.getDocument());
             XPath xpath = XPathFactory.newInstance().newXPath();
-            XmlUtils.assertIsPresent(reporter.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']");
-            XmlUtils.assertAttributes(reporter.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']",
+            XmlUtils.assertIsPresent(output.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']");
+            XmlUtils.assertAttributes(output.getDocument(), xpath, "/rat-report/resource[@name='/foo.md']",
                     XmlUtils.mapOf("type", "IGNORED"));
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(0);
-            assertThat(claimStatistic.getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(2);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(2);
         } catch (IOException | RatException | XPathExpressionException e) {
             fail(e);
         }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 3d9c84e7c..207bd91c5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -19,21 +19,24 @@
 package org.apache.rat;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Fail.fail;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
+import java.io.IOException;
 import java.io.PrintStream;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
 
+import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.stream.Stream;
 import javax.xml.XMLConstants;
 import javax.xml.transform.Source;
 import javax.xml.transform.dom.DOMSource;
@@ -45,25 +48,30 @@
 import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathFactory;
 
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.io.FileUtils;
 import org.apache.rat.api.Document.Type;
 import org.apache.rat.api.RatException;
+import org.apache.rat.commandline.Arg;
 import org.apache.rat.commandline.ArgumentContext;
-import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.document.FileDocument;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.test.utils.Resources;
+import org.apache.rat.testhelpers.BaseOptionCollection;
 import org.apache.rat.testhelpers.TextUtils;
 import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.testhelpers.data.ReportTestDataProvider;
+import org.apache.rat.testhelpers.data.TestData;
+import org.apache.rat.testhelpers.data.ValidatorData;
 import org.apache.rat.walker.DirectoryWalker;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.w3c.dom.Document;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
@@ -75,19 +83,19 @@ public class ReporterTest {
     @TempDir
     File tempDirectory;
     final String basedir;
+    private final OptionCollectionParser collectionParser;
 
     ReporterTest() throws URISyntaxException {
         basedir = Resources.getExampleResource("exampleData").getPath();
+        collectionParser = new OptionCollectionParser(BaseOptionCollection.builder().build());
     }
 
     @Test
-    public void testExecute() throws RatException, ParseException {
+    public void testExecute() throws RatException, ParseException, IOException {
         File output = new File(tempDirectory, "testExecute");
-
-        CommandLine cl = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
-        ArgumentContext ctxt = new ArgumentContext(new File("."), cl);
-        ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
-        ClaimStatistic statistic = new Reporter(config).execute();
+        BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
+        ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
+        ClaimStatistic statistic = new Reporter(ctxt.getConfiguration()).execute().getStatistic();
 
         assertThat(statistic.getCounter(Type.ARCHIVE)).isEqualTo(1);
         assertThat(statistic.getCounter(Type.BINARY)).isEqualTo(2);
@@ -138,11 +146,8 @@ public void testExecute() throws RatException, ParseException {
     @Test
     public void testOutputOption() throws Exception {
         File output = new File(tempDirectory, "test");
-        CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"-o", output.getCanonicalPath(), basedir});
-        ArgumentContext ctxt = new ArgumentContext(new File("."), commandLine);
-
-        ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
-        new Reporter(config).output();
+        ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-file", output.getCanonicalPath(), basedir});
+        new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
         assertThat(output.exists()).isTrue();
         String content = FileUtils.readFileToString(output, StandardCharsets.UTF_8);
         TextUtils.assertPatternInTarget("^! Unapproved:\\s*2 ", content);
@@ -153,15 +158,13 @@ public void testOutputOption() throws Exception {
     @Test
     public void testDefaultOutput() throws Exception {
         File output = new File(tempDirectory, "testDefaultOutput");
+        BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
 
         PrintStream origin = System.out;
         try (PrintStream out = new PrintStream(output)) {
             System.setOut(out);
-            CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{basedir});
-            ArgumentContext ctxt = new ArgumentContext(new File("."), commandLine);
-
-            ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
-            new Reporter(config).output();
+            ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{basedir});
+            new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
         } finally {
             System.setOut(origin);
         }
@@ -211,11 +214,8 @@ public void testXMLOutput() throws Exception {
 
         File output = new File(tempDirectory, ".rat/testXMLOutput");
         output.getParentFile().mkdir();
-        CommandLine commandLine = new DefaultParser().parse(OptionCollection.buildOptions(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
-        ArgumentContext ctxt = new ArgumentContext(tempDirectory, commandLine);
-
-        ReportConfiguration config = OptionCollection.createConfiguration(ctxt);
-        new Reporter(config).output();
+        ArgumentContext ctxt = collectionParser.parseCommands(tempDirectory, new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
+        new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
 
         assertThat(output).exists();
         Document doc = XmlUtils.toDom(java.nio.file.Files.newInputStream(output.toPath()));
@@ -405,13 +405,8 @@ private Validator initValidator() throws SAXException {
 
     @Test
     public void xmlReportTest() throws Exception {
-        ByteArrayOutputStream out = new ByteArrayOutputStream();
-
         ReportConfiguration configuration = initializeConfiguration();
-        configuration.setStyleSheet(StyleSheets.XML.getStyleSheet());
-        configuration.setOut(() -> out);
-        new Reporter(configuration).output();
-        Document doc = XmlUtils.toDom(new ByteArrayInputStream(out.toByteArray()));
+        Document doc = new Reporter(configuration).execute().getDocument();
 
         XPath xPath = XPathFactory.newInstance().newXPath();
 
@@ -457,10 +452,9 @@ public void plainReportTest() throws Exception {
                 "Generated at: ";
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         ReportConfiguration configuration = initializeConfiguration();
-        configuration.setOut(() -> out);
-        new Reporter(configuration).output();
+        configuration.setOut(new ReportConfiguration.IODescriptor<>("plainReportTest", () -> out));
+        new Reporter(configuration).execute().format(configuration);
 
-        out.flush();
         String document = out.toString();
 
         TextUtils.assertNotContains("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", document);
@@ -473,11 +467,10 @@ public void plainReportTest() throws Exception {
     public void unapprovedLicensesReportTest() throws Exception {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         ReportConfiguration configuration = initializeConfiguration();
-        configuration.setOut(() -> out);
+        configuration.setOut(new ReportConfiguration.IODescriptor<>("unapprovedLicensesReportTest", () -> out));
         configuration.setStyleSheet(this.getClass().getResource("/org/apache/rat/unapproved-licenses.xsl"));
-        new Reporter(configuration).output();
+        new Reporter(configuration).execute().format(configuration);
 
-        out.flush();
         String document = out.toString();
 
         TextUtils.assertContains("Generated at: ", document );
@@ -502,21 +495,50 @@ void listLicensesReportTest() throws Exception {
     @Test
     void counterMaxTest() throws Exception {
         ReportConfiguration config = initializeConfiguration();
-        Reporter reporter = new Reporter(config);
-        reporter.output();
+        Reporter.Output output = new Reporter(config).execute();
         assertThat(config.getClaimValidator().hasErrors()).isTrue();
-        assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, reporter.getClaimsStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
+        assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
                 .isFalse();
 
         config = initializeConfiguration();
         config.getClaimValidator().setMax(ClaimStatistic.Counter.UNAPPROVED, 2);
-        reporter = new Reporter(config);
-        reporter.output();
+        output = new Reporter(config).execute();
         assertThat(config.getClaimValidator().hasErrors()).isFalse();
-        assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, reporter.getClaimsStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
+        assertThat(config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)))
                 .isTrue();
     }
 
+    static Stream<Arguments> getTestData() {
+        BaseOptionCollection.Builder builder = BaseOptionCollection.builder()
+                        .unsupported(Arg.OUTPUT_FILE);
+        return new ReportTestDataProvider().getOptionTests(builder.build()).stream().map(testData ->
+                Arguments.of(testData.getTestName(), testData));
+    }
+
+    @ParameterizedTest( name = "{index} {0}")
+    @MethodSource("getTestData")
+    void testReportData(String name, TestData test) throws Exception {
+        Path tempPath = tempDirectory.toPath();
+        Path basePath = tempPath.resolve(test.getTestName());
+        org.apache.rat.utils.FileUtils.mkDir(basePath.toFile());
+        test.setupFiles(basePath);
+        ArgumentContext ctxt = collectionParser.parseCommands(basePath.toFile(),
+                test.getCommandLine(basePath.toString()));
+        if (test.expectingException()) {
+            assertThatThrownBy(() -> new Reporter(ctxt.getConfiguration()).execute()).as("Expected throws from " + name)
+                    .hasMessageContaining(test.getExpectedException().getMessage());
+            ValidatorData data = new ValidatorData(Reporter.Output.builder().configuration(ctxt.getConfiguration()).build(),
+                    basePath.toString());
+            test.getValidator().accept(data);
+        } else {
+            Reporter.Output output = ctxt.getConfiguration() != null ? new Reporter(ctxt.getConfiguration()).execute() :
+                    Reporter.Output.builder().build();
+            ValidatorData data = new ValidatorData(output, basePath.toString());
+            data.getOutput().format(data.getConfiguration());
+            test.getValidator().accept(data);
+        }
+    }
+
     private record LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
             LicenseInfo(String id, boolean approval, boolean hasNotes) {
                 this(id, id, approval, hasNotes);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
index f0779b31f..5d2caa1ed 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
@@ -52,6 +52,10 @@ public class XMLConfigurationReaderTest {
     public static final String[] EXPECTED_LICENSES = {"AL1.0", "AL1.1", "AL2.0", "BSD-3", "DOJO", "TMF", "CDDL1", "ILLUMOS", "GPL1", "GPL2",
             "GPL3", "MIT", "OASIS", "W3C", "W3CD"};
 
+    public static final String[] APPROVED_LICENSES = { "AL1.0", "AL1.1", "AL2.0", "BSD-3", "DOJO", "TMF", "CDDL1", "ILLUMOS",
+            "MIT", "OASIS", "W3C", "W3CD" };
+
+
     @Test
     void approvedLicenseIdTest() throws URISyntaxException {
         XMLConfigurationReader reader = new XMLConfigurationReader();
@@ -59,13 +63,12 @@ void approvedLicenseIdTest() throws URISyntaxException {
         assertThat(url).isNotNull();
         reader.read(url.toURI());
 
-        Collection<String> readCategories = reader.approvedLicenseId();
-        assertThat(readCategories.toArray(new String[readCategories.size()]))
-                .containsExactly(APPROVED_IDS);
+        Collection<String> actual = reader.approvedLicenseId();
+        assertThat(actual).containsExactlyInAnyOrder(APPROVED_IDS);
     }
 
     @Test
-    void LicensesTest() throws URISyntaxException {
+    public void LicensesTest() throws URISyntaxException {
         XMLConfigurationReader reader = new XMLConfigurationReader();
         URL url = XMLConfigurationReaderTest.class.getResource("/org/apache/rat/default.xml");
         reader.read(url.toURI());
@@ -77,10 +80,12 @@ void LicensesTest() throws URISyntaxException {
     void LicenseFamiliesTest() throws URISyntaxException {
         XMLConfigurationReader reader = new XMLConfigurationReader();
         URL url = XMLConfigurationReaderTest.class.getResource("/org/apache/rat/default.xml");
+        assertThat(url).isNotNull();
         reader.read(url.toURI());
 
-        assertThat(reader.readFamilies().stream().map(x -> x.getFamilyCategory().trim()).toArray(String[]::new))
-                .containsExactly(EXPECTED_IDS);
+        Collection<String> actual = reader.readFamilies().stream().map(lf -> lf.getFamilyCategory().trim())
+                .toList();
+        assertThat(actual).containsExactlyInAnyOrder(EXPECTED_IDS);
     }
 
     private void checkMatcher(String name, Class<? extends AbstractBuilder> clazz) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index df5888a88..db53fff04 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -865,7 +865,7 @@ private void styleSheetTest(final Option option) {
             for (String sheet : new String[]{"plain-rat", "missing-headers", "unapproved-licenses", file.getAbsolutePath()}) {
                 args[0] = sheet;
                 ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
-                try (InputStream expected = StyleSheets.getStyleSheet(sheet).get();
+                try (InputStream expected = StyleSheets.getStyleSheet(sheet, DocumentName.builder(baseDir).build()).ioSupplier().get();
                      InputStream actual = config.getStyleSheet().get()) {
                     assertThat(IOUtils.contentEquals(expected, actual)).as(() -> String.format("'%s' does not match", sheet)).isTrue();
                 }
@@ -892,7 +892,7 @@ protected void scanHiddenDirectoriesTest() {
     protected void xmlTest() {
         assertDoesNotThrow(() -> {
             ReportConfiguration config = generateConfig(ImmutablePair.of(Arg.OUTPUT_STYLE.find("xml"), null));
-            try (InputStream expected = StyleSheets.getStyleSheet("xml").get();
+            try (InputStream expected = StyleSheets.getStyleSheet("xml", null).ioSupplier().get();
                  InputStream actual = config.getStyleSheet().get()) {
                 assertThat(IOUtils.contentEquals(expected, actual)).as("'xml' does not match").isTrue();
             }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
new file mode 100644
index 000000000..c6ae379b4
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
@@ -0,0 +1,25 @@
+
+package org.apache.rat.testhelpers;
+
+import org.apache.commons.cli.Option;
+import org.apache.rat.ui.ArgumentTracker;
+import org.apache.rat.ui.UIOption;
+import org.apache.rat.ui.UIOptionCollection;
+import org.apache.rat.utils.CasedString;
+
+public final class BaseOption extends UIOption<BaseOption> {
+    BaseOption(final UIOptionCollection<BaseOption> collection, Option option) {
+        super(collection, option, new CasedString(CasedString.StringCase.KEBAB, ArgumentTracker.extractKey(option)));
+    }
+    protected String cleanupName(Option option) {
+        return ArgumentTracker.extractKey(option);
+    }
+
+    public String getExample() {
+        return "";
+    }
+
+    public String getText() {
+        return "";
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
new file mode 100644
index 000000000..615d8a099
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
@@ -0,0 +1,24 @@
+package org.apache.rat.testhelpers;
+
+import org.apache.commons.cli.Option;
+import org.apache.rat.ui.UIOptionCollection;
+
+public final class BaseOptionCollection extends UIOptionCollection<BaseOption> {
+    private BaseOptionCollection(Builder builder) {
+        super(builder);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static final class Builder extends UIOptionCollection.Builder<BaseOption, Builder> {
+        private Builder() {
+            super(BaseOption::new);
+        }
+
+        public BaseOptionCollection build() {
+            return new BaseOptionCollection(this);
+        }
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
index 171cacacd..0298eb52c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TestingLog.java
@@ -26,6 +26,7 @@
 public class TestingLog implements Log {
 
     private StringBuilder captured = new StringBuilder();
+    private Log.Level level = Log.Level.INFO;
 
     /**
      * Clears the captured buffer
@@ -86,12 +87,18 @@ public void assertNotContainsPattern(String pattern) {
 
     @Override
     public Level getLevel() {
-        return Level.DEBUG;
+        return level;
+    }
+
+    @Override
+    public void setLevel(Level level) {
+        this.level = level;
     }
 
     @Override
     public void log(Level level, String msg) {
-        captured.append(String.format("%s: %s%n", level, msg));
+        if (isEnabled(level))
+            captured.append(String.format("%s: %s%n", level, msg));
     }
 
     /**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
index 94b23a358..6bc5682f8 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
@@ -32,7 +32,7 @@
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.rat.OptionCollectionParser;
 import org.apache.rat.commandline.Arg;
-import org.apache.rat.ui.AbstractOptionCollection;
+import org.apache.rat.ui.UIOptionCollection;
 import org.apache.rat.ui.ArgumentTracker;
 import org.apache.rat.utils.DefaultLog;
 
@@ -40,8 +40,6 @@
  * Generates a list of TestData for executing the Report.
  * Use of this interface ensures consistent testing across the UIs. Each method
  * tests an Option from {@link OptionCollectionParser} that must be implemented in the UI.
- * This differes from the {@link OptionTestDataProvider} in that tests from this set
- * expect that execptions will be thrown during execution, and tests the xml output.
  */
 public abstract class AbstractTestDataProvider {
 
@@ -56,7 +54,7 @@ public abstract class AbstractTestDataProvider {
      * @param optionCollection the collection of options for the UI under test.
      * @return the map of testName to Test Data.
      */
-    public final Map<String, TestData> getOptionTestMap(final AbstractOptionCollection<?> optionCollection) {
+    public final Map<String, TestData> getOptionTestMap(final UIOptionCollection<?> optionCollection) {
         Map<String, TestData> map = new TreeMap<>();
         for (TestData test : getOptionTests(optionCollection)) {
             map.put(test.getTestName(), test);
@@ -71,7 +69,7 @@ public final Map<String, TestData> getOptionTestMap(final AbstractOptionCollecti
      * @param optionCollection the collection of options for the UI under test.
      * @return a set of TestData for the tests.
      */
-    public final Set<TestData> getOptionTests(final AbstractOptionCollection<?> optionCollection) {
+    public final Set<TestData> getOptionTests(final UIOptionCollection<?> optionCollection) {
         // the optionCollection establishes any changes to the Arg values.
         List<Option> unsupportedOptions = new ArrayList<>(optionCollection.getUnsupportedOptions().getOptions());
         Set<TestData> result = new TreeSet<>();
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
new file mode 100644
index 000000000..11ad8ec87
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.testhelpers.data;
+
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Locale;
+import java.util.function.Consumer;
+import org.apache.commons.cli.Option;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.utils.CasedString;
+import org.apache.rat.utils.DefaultLog;
+
+public class DataUtils {
+    /**
+     * The text for the current ASF license.
+     */
+    public static final String[] ASF_TEXT_LINES = {
+            "Licensed to the Apache Software Foundation (ASF) under one or more",
+            "contributor license agreements.  See the NOTICE file distributed with",
+            "this work for additional information regarding copyright ownership.",
+            "The ASF licenses this file to You under the Apache License, Version 2.0",
+            "(the \"License\"); you may not use this file except in compliance with",
+            "the License.  You may obtain a copy of the License at",
+            "  ",
+            "    https://www.apache.org/licenses/LICENSE-2.0",
+            "  ",
+            "Unless required by applicable law or agreed to in writing, software",
+            "distributed under the License is distributed on an \"AS IS\" BASIS,",
+            "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.",
+            "See the License for the specific language governing permissions and",
+            "limitations under the License."
+    };
+
+    /**
+     * The text for the current ASF license as a block of text with new lines.
+     */
+    public static final String ASF_TEXT = String.join("\n" ,ASF_TEXT_LINES);
+
+    /**
+     * A setup that does nothing.
+     */
+    public static final Consumer<Path> NO_SETUP = basePath -> {
+        DefaultLog.getInstance().warn("no setup for " + basePath);
+    };
+
+    public static final Consumer<ValidatorData> NO_VALIDATOR = validatorData -> {};
+
+    private DataUtils() {
+        // do not instantiate
+    }
+
+    /**
+     * Create a directory name from the option.  Directory names are camel.
+     * @param option the option to create a directory name from.
+     * @return the directory name for the option.
+     */
+    static String asDirName(Option option) {
+        if (option.hasLongOpt()) {
+            return CasedString.StringCase.CAMEL.assemble(CasedString.StringCase.KEBAB.getSegments(option.getLongOpt()));
+        }
+        return option.getOpt().toLowerCase(Locale.ROOT);
+    }
+
+    /**
+     * Generate a simple configuration file that defines one license based on the name of the file and
+     * containing as single text matcher that mateches the {@code text} parameter.
+     * @param fileName The name of the file to create.
+     * @param id the ID for the family.
+     * @param text the text for the matcher.
+     */
+    static void generateTextConfig(Path fileName, String id, String text) {
+        try (XmlWriter writer = new XmlWriter(new OutputStreamWriter(Files.newOutputStream(fileName.toFile().toPath()),
+                        StandardCharsets.UTF_8))) {
+            writer.startDocument()
+                    .comment(ASF_TEXT)
+                    .openElement("rat-config")
+                    .openElement("families")
+                    .openElement("family")
+                    .attribute("id", id)
+                    .attribute("name", "from " + fileName.getFileName())
+                    .closeElement() // family
+                    .closeElement() // families
+                    .openElement("licenses")
+                    .openElement("license")
+                    .attribute("family", id)
+                    .openElement("text")
+                    .content(text)
+                    .closeDocument(); // close all open elements
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    /**
+     * Generate a simple configuration file that defines one license based on the name of the file and
+     * containing as single text matcher that mateches the {@code text} parameter.
+     * @param fileName The name of the file to create.
+     * @param id the ID for the family.
+     * @param spdxId the SPDX id for the matcher.
+     */
+    static void generateSpdxConfig(Path fileName, String id, String spdxId) {
+        try (XmlWriter writer = new XmlWriter(new OutputStreamWriter(Files.newOutputStream(fileName.toFile().toPath()),
+                StandardCharsets.UTF_8))) {
+            writer.startDocument()
+                    .comment(ASF_TEXT)
+                    .openElement("rat-config")
+                    .openElement("families")
+                    .openElement("family")
+                    .attribute("id", id)
+                    .attribute("name", "from " + fileName.getFileName())
+                    .closeElement() // family
+                    .closeElement() // families
+                    .openElement("licenses")
+                    .openElement("license")
+                    .attribute("family", id)
+                    .openElement("spdx")
+                    .attribute("name", spdxId)
+                    .closeDocument(); // close all open elements
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
new file mode 100644
index 000000000..399ed50d9
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
@@ -0,0 +1,1282 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.testhelpers.data;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+import org.apache.commons.cli.Option;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.rat.OptionCollectionParser;
+import org.apache.rat.ReportConfiguration;
+import org.apache.rat.api.RatException;
+import org.apache.rat.commandline.Arg;
+import org.apache.rat.commandline.StyleSheets;
+import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.config.results.ClaimValidator;
+import org.apache.rat.document.DocumentName;
+import org.apache.rat.license.LicenseSetFactory;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.utils.FileUtils;
+import org.apache.rat.testhelpers.TestingLog;
+import org.apache.rat.testhelpers.TextUtils;
+import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.Log;
+import org.w3c.dom.Document;
+
+import static org.apache.rat.utils.FileUtils.writeFile;
+import static org.apache.rat.testhelpers.data.DataUtils.NO_SETUP;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Fail.fail;
+
+/**
+ * Generates a list of TestData for executing the Report.
+ * Use of this interface ensures consistent testing across the UIs. Each method
+ * tests an Option from {@link OptionCollectionParser} that must be implemented in the UI.
+ * This differes from the {@link OptionTestDataProvider} in that tests from this set
+ * expect that execptions will be thrown during execution, and tests the xml output.
+ */
+public class ReportTestDataProvider extends AbstractTestDataProvider {
+
+    public static final RatException NO_LICENSES_EXCEPTION = new RatException("At least one license must be defined");
+
+    private final XPath xpath = XPathFactory.newInstance().newXPath();
+
+    private final Consumer<Path> mkRat = basePath -> {
+        DefaultLog.getInstance().warn("mkRat setup for " + basePath);
+        File baseDir = basePath.toFile();
+        File ratDir = new File(baseDir, ".rat");
+        FileUtils.mkDir(ratDir);
+    };
+
+    private void assertStandardFile(Document document, String fname) {
+        try {
+            XmlUtils.assertIsPresent(document, xpath,
+                    String.format("/rat-report/resource[@name='/%s'][@type='STANDARD']", fname));
+        } catch (XPathExpressionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void assertIgnoredFile(Document document, String fname) {
+        try {
+            XmlUtils.assertIsPresent(document, xpath,
+                    String.format("/rat-report/resource[@name='/%s'][@type='IGNORED']", fname));
+        } catch (XPathExpressionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    private void assertCounter(ValidatorData data, ClaimStatistic.Counter counter, int count) {
+        assertThat(data.getStatistic().getCounter(counter)).as(counter.name()).isEqualTo(count);
+    }
+
+    // exclude tests
+    private List<TestData> execExcludeTest(final Option option, final Supplier<String[]> args, Consumer<Path> setupFiles) {
+        Consumer<Path> setup = setupFiles.andThen(mkRat).andThen(basePath -> {
+            DefaultLog.getInstance().warn("execExcludeTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "notbaz");
+            writeFile(baseDir, "well._afile");
+            writeFile(baseDir, "some.foo");
+            writeFile(baseDir, "B.bar");
+            writeFile(baseDir, "justbaz");
+        });
+
+        TestData test1 = new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execExcludeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 5);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 1);
+                });
+
+        String[] ignored = {"B.bar", "justbaz", "some.foo", ".rat"};
+        String[] standard = {"well._afile", "notbaz"};
+        TestData test2 = new TestData("", Collections.singletonList(ImmutablePair.of(option, args.get())),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execExcludeTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, standard.length);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, ignored.length);
+                    for (String fileName : ignored) {
+                        assertIgnoredFile(validatorData.getDocument(), fileName);
+                    }
+                    for (String fileName : standard) {
+                        assertStandardFile(validatorData.getDocument(), fileName);
+                    }
+                });
+        return Arrays.asList(test1, test2);
+    }
+
+    protected void inputExcludeFileTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = mkRat.andThen(baseDir -> {
+            File dir = baseDir.resolve(".rat").toFile();
+            writeFile(dir, "exclude.txt", Arrays.asList(AbstractTestDataProvider.EXCLUDE_ARGS));
+        });
+        Supplier<String[]> args = () -> new String[]{".rat/exclude.txt"};
+        result.addAll(execExcludeTest(option, args, setup));
+    }
+
+
+    protected void inputExcludeTest(final Set<TestData> result, final Option option) {
+        result.addAll(execExcludeTest(option, () -> AbstractTestDataProvider.EXCLUDE_ARGS, x -> {
+        }));
+    }
+
+    protected void inputExcludeStdTest(final Set<TestData> result, final Option option) {
+        String[] args = {StandardCollection.MAVEN.name()};
+        String[] defaultExcluded = {"afile~", ".#afile", "%afile%", "._afile"};
+        String[] defaultIncluded = {"afile~more", "what.#afile", "%afile%withMore", "well._afile"};
+        String mavenFile = "build.log";
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("inputExcludeStdTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            for (String fileName : defaultExcluded) {
+                writeFile(baseDir, fileName);
+            }
+            for (String fileName : defaultIncluded) {
+                writeFile(baseDir, fileName);
+            }
+            writeFile(baseDir, mavenFile);
+        };
+        result.add(new TestData(DataUtils.asDirName(option), Collections.singletonList(ImmutablePair.nullPair()),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeStdTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, defaultIncluded.length + 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, defaultExcluded.length);
+                    for (String fileName : defaultIncluded) {
+                        assertStandardFile(validatorData.getDocument(), fileName);
+                    }
+                    for (String fileName : defaultExcluded) {
+                        assertIgnoredFile(validatorData.getDocument(), fileName);
+                    }
+                }));
+
+
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, args)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeStdTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, defaultIncluded.length);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, defaultExcluded.length + 1);
+                    for (String fileName : defaultIncluded) {
+                        assertStandardFile(validatorData.getDocument(), fileName);
+                    }
+                    for (String fileName : defaultExcluded) {
+                        assertIgnoredFile(validatorData.getDocument(), fileName);
+                    }
+                    assertIgnoredFile(validatorData.getDocument(), mavenFile);
+                }));
+    }
+
+    protected void inputExcludeParsedScmTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("inputExcludeParsedScmTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            String[] lines = {
+                    "# somethings",
+                    "!thingone", "thing*", System.lineSeparator(),
+                    "# some fish",
+                    "**/fish", "*_fish",
+                    "# some colorful directories",
+                    "red/", "blue/*/"};
+            writeFile(baseDir, ".gitignore", Arrays.asList(lines));
+            writeFile(baseDir, "thingone");
+            writeFile(baseDir, "thingtwo");
+            File dir = new File(baseDir, "dir");
+            FileUtils.mkDir(dir);
+            FileUtils.writeFile(dir, "fish_two");
+            FileUtils.writeFile(dir, "fish");
+
+            dir = new File(baseDir, "red");
+            FileUtils.mkDir(dir);
+            FileUtils.writeFile(dir, "fish");
+
+            dir = new File(baseDir, "blue/fish");
+            FileUtils.mkDir(dir);
+            FileUtils.writeFile(dir, "dory");
+
+            dir = new File(baseDir, "some");
+            FileUtils.mkDir(dir);
+            FileUtils.writeFile(dir, "fish");
+            FileUtils.writeFile(dir, "things");
+            FileUtils.writeFile(dir, "thingone");
+
+            dir = new File(baseDir, "another");
+            FileUtils.mkDir(dir);
+            FileUtils.writeFile(dir, "red_fish");
+        };
+
+        result.add(new TestData(DataUtils.asDirName(option), Collections.singletonList(ImmutablePair.nullPair()),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeParsedScmTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 11);
+                    // .gitignore is ignored by default as it is hidden
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 0);
+                }));
+
+        result.add(new TestData("GIT", Collections.singletonList(ImmutablePair.of(option, new String[]{"GIT"})),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeParsedScmTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 3);
+                    // .gitignore is ignored by default as it is hidden
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 8);
+                }));
+    }
+
+    protected void inputExcludeSizeTest(final Set<TestData> result, final Option option) {
+        String[] notExcluded = {"Hello.txt", "HelloWorld.txt"};
+        String[] excluded = {"Hi.txt"};
+
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("inputExcludeSizeTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "Hi.txt", Collections.singletonList("Hi"));
+            writeFile(baseDir, "Hello.txt", Collections.singletonList("Hello"));
+            writeFile(baseDir, "HelloWorld.txt", Collections.singletonList("HelloWorld"));
+        };
+
+        result.add(new TestData(DataUtils.asDirName(option), Collections.singletonList(ImmutablePair.of(null, null)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeSizeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 3);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 0);
+                    for (String fname : excluded) {
+                        assertStandardFile(validatorData.getDocument(), fname);
+                    }
+                    for (String fname : notExcluded) {
+                        assertStandardFile(validatorData.getDocument(), fname);
+                    }
+                }));
+
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, new String[]{"5"})),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputExcludeSizeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 1);
+                    for (String fname : excluded) {
+                        assertIgnoredFile(validatorData.getDocument(), fname);
+                    }
+                    for (String fname : notExcluded) {
+                        assertStandardFile(validatorData.getDocument(), fname);
+                    }
+                }));
+    }
+
+    // include tests
+    private List<TestData> execIncludeTest(final Option option, String[] args, Consumer<Path> setupFiles) {
+        Option excludeOption = Arg.EXCLUDE.option();
+        Consumer<Path> setup = setupFiles.andThen(basePath -> {
+            DefaultLog.getInstance().warn("execIncludeTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "notbaz");
+            writeFile(baseDir, "some.foo");
+            writeFile(baseDir, "B.bar");
+            writeFile(baseDir, "justbaz");
+        });
+
+        // standard without options.
+        TestData test1 = new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execIncludeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 4);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 1);
+                });
+
+        // verify exclude removes the files
+        TestData test2 = new TestData(DataUtils.asDirName(option), Collections.singletonList(ImmutablePair.of(excludeOption, AbstractTestDataProvider.EXCLUDE_ARGS)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execIncludeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    // .gitignore is ignored by default as it is hidden but not counted
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 4);
+                });
+
+        TestData test3 = new TestData("", Arrays.asList(ImmutablePair.of(option, args), ImmutablePair.of(excludeOption, AbstractTestDataProvider.EXCLUDE_ARGS)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execIncludeTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 3);
+                    // .gitignore is ignored by default as it is hidden but not counted
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 2);
+                });
+        return Arrays.asList(test1, test2, test3);
+    }
+
+    protected void inputIncludeFileTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = mkRat.andThen(basePath -> {
+            DefaultLog.getInstance().warn("inputIncludeFileTest setup for " + basePath);
+            File dir = basePath.resolve(".rat").toFile();
+            writeFile(dir, "include.txt", Arrays.asList(AbstractTestDataProvider.INCLUDE_ARGS));
+        });
+        result.addAll(execIncludeTest(option, new String[]{".rat/include.txt"}, setup));
+    }
+
+
+    protected void inputIncludeTest(final Set<TestData> result, final Option option) {
+        result.addAll(execIncludeTest(option, AbstractTestDataProvider.INCLUDE_ARGS, mkRat));
+    }
+
+    protected void inputIncludeStdTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("inputIncludeStdTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "afile~more");
+            writeFile(baseDir, "afile~");
+            writeFile(baseDir, ".#afile");
+            writeFile(baseDir, "%afile%");
+            writeFile(baseDir, "._afile");
+            writeFile(baseDir, "what.#afile");
+            writeFile(baseDir, "%afile%withMore");
+            writeFile(baseDir, "well._afile");
+            writeFile(baseDir, ".hiddenFile", "The hidden file");
+            File hiddenDir = new File(baseDir, ".hiddenDir");
+            FileUtils.mkDir(hiddenDir);
+            writeFile(hiddenDir, "aFile", "File in hidden directory");
+        };
+        if (Arg.EXCLUDE.isEmpty()) {
+            throw new RuntimeException(String.format("Can not test %s if there are no exclude file options supported", option.getKey()));
+        }
+        ImmutablePair<Option, String[]> excludes = ImmutablePair.of(Arg.EXCLUDE.option(),
+                new String[]{"*~more", "*~"});
+
+
+        result.add(new TestData("includeStdValidation", Collections.singletonList(excludes),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputIncludeStdTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 4);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 6);
+                }));
+
+        if (!option.hasArg()) {
+            if (option.getKey().equals("scan-hidden-directories")) {
+                result.add(new TestData("",
+                        Arrays.asList(ImmutablePair.of(option, null), excludes),
+                        setup,
+                        validatorData -> {
+                            DefaultLog.getInstance().warn("validating inputIncludeStdTest for " + validatorData.getBaseDir());
+                            assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 5);
+                            assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 5);
+                            assertIgnoredFile(validatorData.getDocument(), "._afile");
+                            assertStandardFile(validatorData.getDocument(), ".hiddenDir/aFile");
+                        }));
+            } else {
+                throw new RuntimeException("Unknown option: " + option.getKey());
+            }
+        } else {
+            result.add(new TestData(StandardCollection.MISC.name().toLowerCase(Locale.ROOT), Arrays.asList(ImmutablePair.of(option, new String[]{StandardCollection.MISC.name()}), excludes),
+                    setup,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating inputIncludeStdTest for " + validatorData.getBaseDir());
+                        assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 8);
+                        assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 2);
+                    }));
+
+            result.add(new TestData(StandardCollection.HIDDEN_FILE.name().toLowerCase(Locale.ROOT),
+                    Arrays.asList(ImmutablePair.of(option, new String[]{StandardCollection.HIDDEN_FILE.name()}), excludes),
+                    setup,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating inputIncludeStdTest for " + validatorData.getBaseDir());
+                        assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 6);
+                        assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 4);
+                        assertStandardFile(validatorData.getDocument(), "._afile");
+                        assertIgnoredFile(validatorData.getDocument(), ".hiddenDir");
+                    }));
+
+            result.add(new TestData(StandardCollection.HIDDEN_DIR.name().toLowerCase(Locale.ROOT),
+                    Arrays.asList(ImmutablePair.of(option, new String[]{StandardCollection.HIDDEN_DIR.name()}), excludes),
+                    setup,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating inputIncludeStdTest for " + validatorData.getBaseDir());
+                        assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 5);
+                        assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 5);
+                        assertIgnoredFile(validatorData.getDocument(), "._afile");
+                        assertStandardFile(validatorData.getDocument(), ".hiddenDir/aFile");
+                    }));
+        }
+    }
+
+    protected void inputSourceTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("inputSourceTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "codefile", "https://www.apache.org/licenses/LICENSE-2.0");
+            writeFile(baseDir, "input.txt", "codefile");
+            writeFile(baseDir, "notcodeFile");
+        };
+
+        result.add(new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputSourceTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 3);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 0);
+                }));
+
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, new String[]{"input.txt"})),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating inputSourceTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, 0);
+                }));
+    }
+
+    // LICENSE tests
+    protected List<TestData> execLicensesApprovedTest(final Option option, String[] args, Consumer<Path> extraSetup) {
+        Consumer<Path> setup = extraSetup.andThen(
+                basePath -> {
+                    DefaultLog.getInstance().warn("execLicensesApprovedTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "catz.txt", "SPDX-License-Identifier: catz");
+                    writeFile(baseDir, "apl.txt", "SPDX-License-Identifier: Apache-2.0");
+                }
+        );
+
+        TestData test1 = new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicensesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                });
+
+        TestData test2 = new TestData("withoutLicenseDef", Collections.singletonList(ImmutablePair.of(option, args)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicensesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                });
+
+        Option configOpt = Arg.CONFIGURATION.option();
+        TestData test3 = new TestData("withLicenseDef", Arrays.asList(ImmutablePair.of(option, args),
+                ImmutablePair.of(configOpt, new String[]{".rat/catz.xml"})),
+                setup.andThen(mkRat).andThen(
+                        basePath -> {
+                            DefaultLog.getInstance().warn("withLicenseDef setup for " + basePath);
+                            DataUtils.generateSpdxConfig(basePath.resolve(".rat").resolve("catz.xml"), "catz", "catz");
+                        }),
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicensesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 0);
+                });
+        return Arrays.asList(test1, test2, test3);
+    }
+
+    protected void helpLicenses(final Set<TestData> result, final Option option) {
+        PrintStream origin = System.out;
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        PrintStream out = new PrintStream(baos);
+
+        result.add(new TestData("stdOut",
+                Collections.singletonList(ImmutablePair.of(option, null)),
+                basePath -> {
+                    DefaultLog.getInstance().warn("helpLicenses setup for " + basePath);
+                    System.setOut(out);
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating helpLicenses for " + validatorData.getBaseDir());
+                    System.setOut(origin);
+                    String txt = baos.toString();
+                    TextUtils.assertContains("====== Licenses ======", txt);
+                    TextUtils.assertContains("====== Defined Matchers ======", txt);
+                    TextUtils.assertContains("====== Defined Families ======", txt);
+                }));
+    }
+
+    protected void licensesApprovedFileTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicensesApprovedTest(option, new String[]{".rat/licensesApproved.txt"},
+                mkRat.andThen(
+                        basePath -> {
+                            DefaultLog.getInstance().warn("licensesApprovedFileTest setup for " + basePath);
+                            writeFile(basePath.resolve(".rat").toFile(), "licensesApproved.txt", List.of("catz"));
+                        })));
+    }
+
+    protected void licensesApprovedTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicensesApprovedTest(option, new String[]{"catz"}, NO_SETUP));
+    }
+
+    private List<TestData> execLicensesDeniedTest(final Option option, final String[] args, Consumer<Path> setupFiles) {
+        Consumer<Path> setup = setupFiles.andThen(basePath -> {
+            DefaultLog.getInstance().warn("execLicensesDeniedTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "illumousFile.java", "The contents of this file are " +
+                    "subject to the terms of the Common Development and Distribution License (the \"License\") You " +
+                    "may not use this file except in compliance with the License.");
+        });
+        TestData test1 = new TestData("ILLUMOS", Collections.singletonList(ImmutablePair.of(option, args)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicensesDeniedTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    ClaimValidator validator = validatorData.getConfiguration().getClaimValidator();
+                    assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+                });
+        return Collections.singletonList(test1);
+    }
+
+    protected void licensesDeniedTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicensesDeniedTest(option, new String[]{"ILLUMOS"}, NO_SETUP));
+    }
+
+    protected void licensesDeniedFileTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicensesDeniedTest(option, new String[]{"licensesDenied.txt"},
+                (basePath) -> writeFile(basePath.toFile(), "licensesDenied.txt", Collections.singletonList("ILLUMOS"))));
+    }
+
+    private List<TestData> execLicenseFamiliesApprovedTest(final Option option, final String[] args, Consumer<Path> extraSetup) {
+        Consumer<Path> setup = extraSetup.andThen(
+                basePath -> {
+                    DefaultLog.getInstance().warn("execLicenseFamiliesApprovedTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "catz.txt", "SPDX-License-Identifier: catz");
+                });
+
+        TestData test1 = new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicenseFamiliesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 0);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                });
+
+        TestData test2 = new TestData("withoutLicenseDef", Collections.singletonList(ImmutablePair.of(option, args)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicenseFamiliesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 0);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                });
+        Option configOpt = Arg.CONFIGURATION.option();
+        TestData test3 = new TestData("withLicenseDef", Arrays.asList(ImmutablePair.of(option, args),
+                ImmutablePair.of(configOpt, new String[]{".rat/catz.xml"})),
+                setup.andThen(mkRat).andThen(
+                        basePath -> {
+                            DefaultLog.getInstance().warn("withLicenseDef setup for " + basePath);
+                            Path ratDir = basePath.resolve(".rat");
+                            Path catzXml = ratDir.resolve("catz.xml");
+                            DataUtils.generateSpdxConfig(catzXml, "catz", "catz");
+                        }),
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicenseFamiliesApprovedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 0);
+                });
+        return Arrays.asList(test1, test2, test3);
+    }
+
+    protected void licenseFamiliesApprovedFileTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicenseFamiliesApprovedTest(option, new String[]{".rat/familiesApproved.txt"},
+                mkRat.andThen(basePath -> {
+                    DefaultLog.getInstance().warn("licenseFamiliesApprovedFileTest setup for " + basePath);
+                    writeFile(basePath.resolve(".rat").toFile(), "familiesApproved.txt", Collections.singletonList("catz"));
+                })));
+    }
+
+    protected void licenseFamiliesApprovedTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicenseFamiliesApprovedTest(option, new String[]{"catz"}, NO_SETUP));
+    }
+
+    private List<TestData> execLicenseFamiliesDeniedTest(final Option option, final String[] args, Consumer<Path> extraSetup) {
+        Consumer<Path> setup = extraSetup.andThen(
+                basePath -> {
+                    DefaultLog.getInstance().warn("execLicenseFamiliesDeniedTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "bsd.txt", "SPDX-License-Identifier: BSD-3-Clause");
+                });
+
+        TestData test1 = new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicenseFamiliesDeniedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 0);
+                });
+
+        TestData test2 = new TestData("", Collections.singletonList(ImmutablePair.of(option, args)),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating execLicenseFamiliesDeniedTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 0);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                });
+
+        return Arrays.asList(test1, test2);
+    }
+
+    protected void licenseFamiliesDeniedFileTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicenseFamiliesDeniedTest(option, new String[]{".rat/familiesDenied.txt"},
+                mkRat.andThen(
+                        basePath -> {
+                            DefaultLog.getInstance().warn("licenseFamiliesDeniedFileTest setup for " + basePath);
+                            writeFile(basePath.resolve(".rat").toFile(), "familiesDenied.txt", Collections.singletonList("BSD-3"));
+                        })));
+    }
+
+    protected void licenseFamiliesDeniedTest(final Set<TestData> result, final Option option) {
+        result.addAll(execLicenseFamiliesDeniedTest(option, new String[]{"BSD-3"}, NO_SETUP));
+    }
+
+    protected void counterMaxTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData(DataUtils.asDirName(option), Collections.singletonList(ImmutablePair.of(null, null)),
+                basePath -> {
+                    DefaultLog.getInstance().warn("counterMaxTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Unapproved\n",
+                            "*/\n\n", "class Test {}\n"));
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating counterMaxTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    ClaimValidator validator = validatorData.getConfiguration().getClaimValidator();
+                    assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+                }));
+
+        result.add(new TestData("Unapproved1", Collections.singletonList(ImmutablePair.of(option, new String[]{"Unapproved:1"})),
+                basePath -> {
+                    DefaultLog.getInstance().warn("counterMaxTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Unapproved\n",
+                            "*/\n\n", "class Test {}\n"));
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating counterMaxTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    ClaimValidator validator = validatorData.getConfiguration().getClaimValidator();
+                    assertThat(validator.listIssues(claimStatistic)).isEmpty();
+                }));
+    }
+
+    protected void counterMinTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                basePath -> {
+                    DefaultLog.getInstance().warn("counterMinTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Unapproved\n",
+                            "*/\n\n", "class Test {}\n"));
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating counterMinTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    ClaimValidator validator = validatorData.getConfiguration().getClaimValidator();
+                    assertThat(validator.listIssues(claimStatistic)).containsExactly("UNAPPROVED");
+                }));
+
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, new String[]{"Unapproved:1"})),
+                basePath -> {
+                    DefaultLog.getInstance().warn("counterMinTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Unapproved\n",
+                            "*/\n\n", "class Test {}\n"));
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating counterMinTest for " + validatorData.getBaseDir());
+                    ClaimStatistic claimStatistic = validatorData.getStatistic();
+                    ClaimValidator validator = validatorData.getConfiguration().getClaimValidator();
+                    assertThat(validator.listIssues(claimStatistic)).isEmpty();
+                }));
+    }
+
+    /**
+     * Add results to the result list.
+     *
+     * @param result the result list.
+     * @param option configuration option we are testing.
+     */
+    protected void configTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = mkRat.andThen(basePath -> {
+            DefaultLog.getInstance().warn("configTest setup for " + basePath);
+            Path ratDir = basePath.resolve(".rat");
+            Path oneXml = ratDir.resolve("One.xml");
+            DataUtils.generateTextConfig(oneXml, "ONE", "one");
+
+            Path twoXml = ratDir.resolve("Two.xml");
+            DataUtils.generateTextConfig(twoXml, "TWO", "two");
+
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "bsd.txt", "SPDX-License-Identifier: BSD-3-Clause");
+            writeFile(baseDir, "one.txt", "one is the loneliest number");
+        });
+        String[] args = {".rat/One.xml", ".rat/Two.xml"};
+
+        ImmutablePair<Option, String[]> underTest = ImmutablePair.of(option, args);
+
+        result.add(new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating configTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                }));
+
+        result.add(new TestData("withDefaults", Collections.singletonList(underTest),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating configTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 2);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 0);
+                }));
+
+        if (!Arg.CONFIGURATION_NO_DEFAULTS.isEmpty()) {
+            result.add(new TestData("noDefaults", Arrays.asList(underTest,
+                    ImmutablePair.of(Arg.CONFIGURATION_NO_DEFAULTS.find("configuration-no-defaults"), null)),
+                    setup,
+                    /** Make validator data a structure with counter countes  and file checks. */
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating configTest for " + validatorData.getBaseDir());
+                        assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 2);
+                        assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                        assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 1);
+                    }));
+        }
+    }
+
+    protected void configurationNoDefaultsTest(final Set<TestData> result, final Option option) {
+        TestData test1 = new TestData("", Collections.singletonList(ImmutablePair.of(option, null)),
+                basePath -> {
+                    DefaultLog.getInstance().warn("configurationNoDefaultsTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Apache-2.0\n",
+                            "*/\n\n", "class Test {}\n"));
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating configurationNoDefaultsTest for " + validatorData.getBaseDir());
+                    assertThat(validatorData.getConfiguration().getLicenses(LicenseSetFactory.LicenseFilter.ALL)).isEmpty();
+                });
+        test1.setException(NO_LICENSES_EXCEPTION);
+        result.add(test1);
+    }
+
+    protected void dryRunTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData("stdRun", Collections.singletonList(ImmutablePair.of(option, null)),
+                NO_SETUP,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating dryRunTest for " + validatorData.getBaseDir());
+                    assertThat(validatorData.getConfiguration().isDryRun()).as("testing getConfiguration().isDryRun() flag").isTrue();
+                }));
+
+        result.add(new TestData(DataUtils.asDirName(option), NO_OPTIONS,
+                NO_SETUP,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating dryRunTest for " + validatorData.getBaseDir());
+                    assertThat(validatorData.getConfiguration().isDryRun()).as("testing getConfiguration().isDryRun() flag").isFalse();
+                }));
+    }
+
+    protected void editCopyrightTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("editCopyrightTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "Missing.java", Arrays.asList("/* no license */\n\n", "class Test {}\n"));
+        };
+        ImmutablePair<Option, String[]> copyright = ImmutablePair.of(option, new String[]{"MyCopyright"});
+        if (Arg.EDIT_ADD.isEmpty()) {
+            throw new RuntimeException("Can not execute copyright tests without an EDIT_ADD option avialable");
+        }
+        ImmutablePair<Option, String[]> editLicense = ImmutablePair.of(Arg.EDIT_ADD.option(), null);
+
+        result.add(new TestData("noEditLicense", Collections.singletonList(copyright),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating editCopyrightTest for " + validatorData.getBaseDir());
+                    try {
+                        String actualText = TextUtils.readFile(validatorData.getBaseDir().resolve("Missing.java").toFile());
+                        TextUtils.assertNotContains("MyCopyright", actualText);
+                    } catch (IOException ex) {
+                        throw new RuntimeException(ex);
+                    }
+                }));
+
+        result.add(new TestData(DataUtils.asDirName(editLicense.getLeft()), Arrays.asList(copyright, editLicense),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating editCopyrightTest for " + validatorData.getBaseDir());
+                    try {
+                        String actualText = TextUtils.readFile(validatorData.getBaseDir().resolve("Missing.java").toFile());
+                        TextUtils.assertNotContains("MyCopyright", actualText);
+                        assertThat(validatorData.getBaseDir().resolve("Missing.java.new")).exists();
+                        actualText = TextUtils.readFile(validatorData.getBaseDir().resolve("Missing.java.new").toFile());
+                        TextUtils.assertContains("MyCopyright", actualText);
+                    } catch (IOException ex) {
+                        throw new RuntimeException(ex);
+                    }
+                }));
+
+        if (!Arg.DRY_RUN.isEmpty()) {
+            Option dryRun = Arg.DRY_RUN.option();
+            result.add(new TestData(DataUtils.asDirName(dryRun),
+                    Arrays.asList(copyright, ImmutablePair.of(dryRun, null), editLicense),
+                    setup,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating editCopyrightTest for " + validatorData.getBaseDir());
+                        try {
+                            String actualText = TextUtils.readFile(validatorData.getBaseDir().resolve("Missing.java").toFile());
+                            TextUtils.assertNotContains("MyCopyright", actualText);
+                        } catch (IOException ex) {
+                            throw new RuntimeException(ex);
+                        }
+                        assertThat(validatorData.getBaseDir().resolve("Missing.java.new")).doesNotExist();
+                    }));
+        }
+
+        if (!Arg.EDIT_OVERWRITE.isEmpty()) {
+            Option overwrite = Arg.EDIT_OVERWRITE.option();
+            result.add(new TestData(DataUtils.asDirName(overwrite), Arrays.asList(copyright, editLicense, ImmutablePair.of(overwrite, null)),
+                    setup,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating editCopyrightTest for " + validatorData.getBaseDir());
+                        try {
+                            String actualText = TextUtils.readFile(validatorData.getBaseDir().resolve("Missing.java").toFile());
+                            TextUtils.assertContains("MyCopyright", actualText);
+                            assertThat(validatorData.getBaseDir().resolve("Missing.java.new")).doesNotExist();
+                        } catch (IOException ex) {
+                            throw new RuntimeException(ex);
+                        }
+                    }));
+        }
+    }
+
+    protected void editLicenseTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, null)),
+                basePath -> {
+                    DefaultLog.getInstance().warn("editLicenseTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "NoLicense.java", "class NoLicense {}");
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating editLicenseTest for " + validatorData.getBaseDir());
+                    try {
+                        assertThat(validatorData.getStatistic()).isNotNull();
+                        File javaFile = validatorData.getBaseDir().resolve("NoLicense.java").toFile();
+                        String contents = String.join("\n", IOUtils.readLines(new FileReader(javaFile)));
+                        assertThat(contents).isEqualTo("class NoLicense {}");
+                        File resultFile = validatorData.getBaseDir().resolve("NoLicense.java.new").toFile();
+                        assertThat(resultFile).exists();
+                        contents = String.join("\n", IOUtils.readLines(new FileReader(resultFile)));
+                        assertThat(contents).isEqualTo("""
+                                /*
+                                 * Licensed to the Apache Software Foundation (ASF) under one
+                                 * or more contributor license agreements.  See the NOTICE file
+                                 * distributed with this work for additional information
+                                 * regarding copyright ownership.  The ASF licenses this file
+                                 * to you under the Apache License, Version 2.0 (the
+                                 * "License"); you may not use this file except in compliance
+                                 * with the License.  You may obtain a copy of the License at
+                                 *\s
+                                 *   http://www.apache.org/licenses/LICENSE-2.0
+                                 *\s
+                                 * Unless required by applicable law or agreed to in writing,
+                                 * software distributed under the License is distributed on an
+                                 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+                                 * KIND, either express or implied.  See the License for the
+                                 * specific language governing permissions and limitations
+                                 * under the License.
+                                 */
+                                
+                                class NoLicense {}""");
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }));
+    }
+
+    protected void editOverwriteTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData("noEditLicense", Collections.singletonList(ImmutablePair.of(option, null)),
+                NO_SETUP,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating editOverwriteTest for " + validatorData.getBaseDir());
+                    assertThat(validatorData.getConfiguration().isAddingLicensesForced())
+                            .describedAs("Without edit-license should be false").isFalse();
+                }));
+
+        if (!Arg.EDIT_ADD.isEmpty()) {
+            result.add(new TestData("", Arrays.asList(ImmutablePair.of(option, null),
+                    ImmutablePair.of(Arg.EDIT_ADD.find("edit-license"), null)),
+                    NO_SETUP,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating editOverwriteTest for " + validatorData.getBaseDir());
+                        assertThat(validatorData.getConfiguration().isAddingLicensesForced())
+                                .as("testing getConfiguration().isAddingLicensesForced() flag").isTrue();
+                    }));
+        }
+    }
+
+    protected void logLevelTest(final Set<TestData> result, final Option option) {
+        final TestingLog testingLog = new TestingLog();
+
+        Consumer<Path> setup = basePath -> {
+            DefaultLog.getInstance().warn("logLevelTest setup for " + basePath);
+            DefaultLog.setInstance(testingLog);
+            testingLog.clear();
+        };
+
+        result.add(new TestData(Log.Level.INFO.name(),
+                Collections.singletonList(ImmutablePair.of(option, new String[]{Log.Level.INFO.name()})),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating logLevelTest for " + validatorData.getBaseDir());
+                    try {
+                        testingLog.assertNotContains("DEBUG");
+                    } finally {
+                        DefaultLog.setInstance(null);
+                    }
+                }));
+
+        result.add(new TestData(Log.Level.DEBUG.name(),
+                Collections.singletonList(ImmutablePair.of(option, new String[]{Log.Level.DEBUG.name()})),
+                setup,
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating logLevelTest for " + validatorData.getBaseDir());
+                    try {
+                        testingLog.assertContains("DEBUG");
+                    } finally {
+                        DefaultLog.setInstance(null);
+                    }
+                }));
+    }
+
+    protected void outputArchiveTest(final Set<TestData> result, final Option option) {
+        for (ReportConfiguration.Processing processing : ReportConfiguration.Processing.values()) {
+            result.add(new TestData(processing.name().toLowerCase(Locale.ROOT),
+                    Collections.singletonList(ImmutablePair.of(option, new String[]{processing.name()})),
+                    basePath -> {
+                        DefaultLog.getInstance().warn("outputArchiveTest setup for " + basePath);
+                        File localArchive = new File(basePath.toFile(), "dummy.jar");
+                        try (InputStream in = ReportTestDataProvider.class.getResourceAsStream("/tikaFiles/archive/dummy.jar");
+                             OutputStream out = Files.newOutputStream(localArchive.toPath())) {
+                            Objects.requireNonNull(in);
+                            IOUtils.copy(in, out);
+                        } catch (IOException e) {
+                            throw new RuntimeException(e);
+                        }
+                    },
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating outputArchiveTest for " + validatorData.getBaseDir());
+                        Document document = validatorData.getDocument();
+                        try {
+                            XmlUtils.assertIsPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']");
+                            switch (processing) {
+                                case ABSENCE:
+                                    XmlUtils.assertIsPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='AL   ']");
+                                    XmlUtils.assertIsPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='?????']");
+                                    break;
+                                case PRESENCE:
+                                    XmlUtils.assertIsPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='AL   ']");
+                                    XmlUtils.assertIsNotPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='?????']");
+                                    break;
+                                case NOTIFICATION:
+                                    XmlUtils.assertIsNotPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='AL   ']");
+                                    XmlUtils.assertIsNotPresent(processing.name(), document, xpath, "/rat-report/resource[@name='/dummy.jar']/license[@family='?????']");
+                                    break;
+                                default:
+                                    throw new IllegalArgumentException("Unexpected processing " + processing);
+                            }
+                        } catch (XPathExpressionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+            );
+        }
+    }
+
+    protected void outputFamiliesTest(final Set<TestData> result, final Option option) {
+        for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
+            result.add(new TestData(filter.name().toLowerCase(Locale.ROOT),
+                    Collections.singletonList(ImmutablePair.of(option, new String[]{filter.name()})),
+                    NO_SETUP,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating outputFamiliesTest for " + validatorData.getBaseDir());
+                        Document document = validatorData.getDocument();
+                        try {
+                            switch (filter) {
+                                case ALL:
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='AL']");
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='GPL']");
+                                    break;
+                                case APPROVED:
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='AL']");
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='GPL']");
+                                    break;
+                                case NONE:
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='AL']");
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/families/family[@id='GPL']");
+                                    break;
+                                default:
+                                    throw new IllegalArgumentException("Unexpected filter: " + filter);
+                            }
+                        } catch (XPathExpressionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    })
+            );
+        }
+    }
+
+    protected void outputFileTest(final Set<TestData> result, final Option option) {
+        result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, new String[]{"outexample"})),
+                basePath -> {
+                    DefaultLog.getInstance().warn("outputFileTest setup for " + basePath);
+                    File baseDir = basePath.toFile();
+                    writeFile(baseDir, "apl.txt", "SPDX-License-Identifier: Apache-2.0");
+                },
+                validatorData -> {
+                    DefaultLog.getInstance().warn("validating outputFamiliesTest for " + validatorData.getBaseDir());
+                    assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.APPROVED, 1);
+                    assertCounter(validatorData, ClaimStatistic.Counter.UNAPPROVED, 0);
+                    File outFile = validatorData.getBaseDir().resolve("outexample").toFile();
+
+                    try {
+                        String actualText = TextUtils.readFile(outFile);
+                        TextUtils.assertPatternInTarget("Apache License 2.0: \\d", actualText);
+                        TextUtils.assertPatternInTarget("STANDARD:\\s+\\d", actualText);
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+        );
+    }
+
+    protected void outputLicensesTest(final Set<TestData> result, final Option option) {
+        for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
+            result.add(new TestData(filter.name(), Collections.singletonList(ImmutablePair.of(option, new String[]{filter.name()})),
+                    NO_SETUP,
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating outputLicensesTest for " + validatorData.getBaseDir());
+                        Document document = validatorData.getDocument();
+                        try {
+                            switch (filter) {
+                                case ALL:
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='AL2.0']");
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='GPL1']");
+                                    break;
+                                case APPROVED:
+                                    XmlUtils.assertIsPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='AL2.0']");
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='GPL1']");
+                                    break;
+                                case NONE:
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='AL2.0']");
+                                    XmlUtils.assertIsNotPresent(filter.name(), document, xpath, "/rat-report/rat-config/licenses/license[@id='GPL1']");
+                                    break;
+                                default:
+                                    throw new IllegalArgumentException("Unexpected filter: " + filter);
+                            }
+                        } catch (XPathExpressionException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }));
+        }
+    }
+
+
+    protected void outputStandardTest(final Set<TestData> result, final Option option) {
+        for (ReportConfiguration.Processing proc : ReportConfiguration.Processing.values()) {
+            result.add(new TestData(proc.name().toLowerCase(Locale.ROOT), Collections.singletonList(ImmutablePair.of(option, new String[]{proc.name()})),
+                    basePath -> {
+                        DefaultLog.getInstance().warn("outputStandardTest setup for " + basePath);
+                        File baseDir = basePath.toFile();
+                        writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Apache-2.0\n",
+                                "*/\n\n", "class Test {}\n"));
+                        writeFile(baseDir, "Missing.java", Arrays.asList("/* no license */\n\n", "class Test {}\n"));
+                    },
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating outputStandardTest for " + validatorData.getBaseDir());
+                        Document document = validatorData.getDocument();
+                        String testDoc = "/rat-report/resource[@name='/Test.java']";
+                        String missingDoc = "/rat-report/resource[@name='/Missing.java']";
+                        try {
+                            XmlUtils.assertIsPresent(proc.name(), document, xpath, testDoc);
+                            XmlUtils.assertIsPresent(proc.name(), document, xpath, missingDoc);
+
+                            switch (proc) {
+                                case ABSENCE:
+                                    XmlUtils.assertIsPresent(proc.name(), document, xpath, testDoc + "/license[@family='AL   ']");
+                                    XmlUtils.assertIsPresent(proc.name(), document, xpath, missingDoc + "/license[@family='?????']");
+                                    break;
+                                case PRESENCE:
+                                    XmlUtils.assertIsPresent(proc.name(), document, xpath, testDoc + "/license[@family='AL   ']");
+                                    XmlUtils.assertIsNotPresent(proc.name(), document, xpath, missingDoc + "/license[@family='?????']");
+                                    break;
+                                case NOTIFICATION:
+                                    XmlUtils.assertIsNotPresent(proc.name(), document, xpath, testDoc + "/license[@family='AL   ']");
+                                    XmlUtils.assertIsNotPresent(proc.name(), document, xpath, missingDoc + "/license[@family='?????']");
+                                    break;
+                                default:
+                                    throw new IllegalArgumentException("Unexpected processing " + proc);
+                            }
+                        } catch (XPathExpressionException ex) {
+                            throw new RuntimeException(ex);
+                        }
+                    }));
+        }
+    }
+
+
+    protected void outputStyleTest(final Set<TestData> result, final Option option) {
+        Consumer<Path> createFile = basePath -> {
+            DefaultLog.getInstance().warn("outputStyleTest setup for " + basePath);
+            File baseDir = basePath.toFile();
+            writeFile(baseDir, "Test.java", Arrays.asList("/*\n", "SPDX-License-Identifier: Apache-2.0\n",
+                    "*/\n\n", "class Test {}\n"));
+            writeFile(baseDir, "Missing.java", Arrays.asList("/* no license */\n\n", "class Test {}\n"));
+        };
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        if (!option.hasArg()) {
+            if (option.getLongOpt().equals("xml")) {
+                result.add(new TestData("", Collections.singletonList(ImmutablePair.of(option, null)),
+                        createFile,
+                        validatorData -> {
+                            DefaultLog.getInstance().warn("validating outputStyleTest for " + validatorData.getBaseDir());
+                            try (InputStream expected = StyleSheets.XML.getStyleSheet().ioSupplier().get();
+                                 InputStream actual = validatorData.getConfiguration().getStyleSheet().get()) {
+                                assertThat(IOUtils.contentEquals(expected, actual)).as(() -> String.format("'%s' does not match", StyleSheets.XML)).isTrue();
+                                baos.reset();
+                                validatorData.getOutput().format(validatorData.getConfiguration().getStyleSheet(), () -> baos);
+                                String actualText = baos.toString();
+                                TextUtils.assertContainsExactly(1, "<resource encoding=\"ISO-8859-1\" mediaType=\"text/x-java-source\" name=\"/Test.java\" type=\"STANDARD\">", actualText);
+                                TextUtils.assertContainsExactly(1, "<resource encoding=\"ISO-8859-2\" mediaType=\"text/x-java-source\" name=\"/Missing.java\" type=\"STANDARD\">", actualText);
+                            } catch (IOException | RatException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }));
+            }
+        } else {
+            for (StyleSheets sheet : StyleSheets.values()) {
+                result.add(new TestData(sheet.name().toLowerCase(Locale.ROOT), Collections.singletonList(ImmutablePair.of(option, new String[]{sheet.arg()})),
+                        createFile,
+                        validatorData -> {
+                            DefaultLog.getInstance().warn("validating outputStyleTest for " + validatorData.getBaseDir());
+                            try (InputStream expected = sheet.getStyleSheet().ioSupplier().get();
+                                 InputStream actual = validatorData.getConfiguration().getStyleSheet().get()) {
+                                assertThat(IOUtils.contentEquals(expected, actual)).as(() -> String.format("'%s' does not match", sheet)).isTrue();
+                                baos.reset();
+                                validatorData.getOutput().format(validatorData.getConfiguration().getStyleSheet(), () -> baos);
+                                String actualText = baos.toString();
+                                switch (sheet) {
+                                    case MISSING_HEADERS:
+                                        TextUtils.assertContainsExactly(1, "Files with missing headers:" + System.lineSeparator() +
+                                                "  /Missing.java", actualText);
+                                        break;
+                                    case PLAIN:
+                                        TextUtils.assertContainsExactly(1, "Unknown license: 1 ", actualText);
+                                        TextUtils.assertContainsExactly(1, "?????: 1 ", actualText);
+                                        break;
+                                    case XML:
+                                        TextUtils.assertContainsExactly(1, "<resource encoding=\"ISO-8859-1\" mediaType=\"text/x-java-source\" name=\"/Test.java\" type=\"STANDARD\">", actualText);
+                                        TextUtils.assertContainsExactly(1, "<resource encoding=\"ISO-8859-2\" mediaType=\"text/x-java-source\" name=\"/Missing.java\" type=\"STANDARD\">", actualText);
+                                        break;
+                                    case UNAPPROVED_LICENSES:
+                                        TextUtils.assertContainsExactly(1, "Files with unapproved licenses:" + System.lineSeparator() + "  /Missing.java", actualText);
+                                        break;
+                                    case XHTML5:
+                                        TextUtils.assertPatternInTarget("<td>Approved<\\/td>\\s+<td>\\d+<\\/td>\\s+<td>A count of approved licenses.<\\/td>", actualText);
+                                        break;
+                                    default:
+                                        fail("No test for stylesheet " + sheet);
+                                        break;
+                                }
+                            } catch (IOException | RatException e) {
+                                throw new RuntimeException(e);
+                            }
+                        }));
+            }
+
+            result.add(new TestData("fileStyleSheet",
+                    Collections.singletonList(ImmutablePair.of(option, new String[]{"fileStyleSheet.xslt"})),
+                    basePath -> {
+                        DefaultLog.getInstance().warn("outputStyleTest setup for " + basePath);
+                        DocumentName name = DocumentName.builder().setName("fileStyleSheet.xslt")
+                                .setBaseName(basePath.toString()).build();
+                        try (FileWriter fileWriter = new FileWriter(new File(name.getBaseName(), name.getName()));
+                             XmlWriter writer = new XmlWriter(fileWriter)) {
+                            writer.startDocument()
+                                    .comment(DataUtils.ASF_TEXT)
+                                    .openElement("xsl:stylesheet")
+                                    .attribute("version", "1.0")
+                                    .attribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform")
+                                    .openElement("xsl:template")
+                                    .attribute("match", "@*|node()")
+                                    .content("Hello World")
+                                    .closeDocument();
+                        } catch (IOException e) {
+                            fail(e.getMessage(), e);
+                        }
+                    },
+
+                    validatorData -> {
+                        DefaultLog.getInstance().warn("validating outputStyleTest for " + validatorData.getBaseDir());
+                        try (InputStream expected = StyleSheets.getStyleSheet("fileStyleSheet.xslt", validatorData.getBaseName()).ioSupplier().get();
+                             InputStream actual = validatorData.getConfiguration().getStyleSheet().get()) {
+                            assertThat(IOUtils.contentEquals(expected, actual)).as(() -> "'fileStyleSheet.xslt' does not match").isTrue();
+                            baos.reset();
+                            validatorData.getOutput().format(validatorData.getConfiguration().getStyleSheet(), () -> baos);
+                            String actualText = baos.toString();
+                            TextUtils.assertContainsExactly(1, "Hello World", actualText);
+                        } catch (IOException | RatException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }));
+        }
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
index c1fcefdbb..84c8c213f 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/TestData.java
@@ -21,26 +21,16 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
 import java.util.function.Consumer;
-import javax.xml.xpath.XPathExpressionException;
 import org.apache.commons.cli.Option;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.commons.text.WordUtils;
-import org.apache.rat.report.claim.ClaimStatistic;
-import org.apache.rat.testhelpers.XmlUtils;
 import org.apache.rat.ui.ArgumentTracker;
 import org.apache.rat.utils.CasedString;
 import org.apache.rat.utils.FileUtils;
-import org.w3c.dom.Document;
-
-import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * The definition of a test.
@@ -52,7 +42,7 @@ public final class TestData implements Comparable<TestData> {
     private final String name;
     /** The command line for the test */
     private final List<ImmutablePair<Option, String[]>> commandLine;
-    /** A function to setup the test in a specific path */
+    /** A function to set up the test in a specific path */
     private final Consumer<Path> setupFiles;
     /** A function to test the results of the test. */
     private final Consumer<ValidatorData> validator;
@@ -116,8 +106,8 @@ public String getName() {
     }
 
     /**
-     * Gets the expected excepton or {@code null} if not exception is expected.
-     * @return the expected excepton or {@code null} if not exception is expected.
+     * Gets the expected exception or {@code null} if not exception is expected.
+     * @return the expected exception or {@code null} if not exception is expected.
      */
     public Exception getExpectedException() {
         return expectedException;
@@ -176,7 +166,7 @@ public String[] getCommandLine(String workingDir) {
 
     /**
      * Get the arguments for the command line.
-     * @return the argumentsfor the command line as Option, String[] pairs.
+     * @return the arguments for the command line as Option, String[] pairs.
      */
     public List<? extends Pair<Option, String[]>> getArgs() {
         return commandLine;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java
index 55185d668..a4745fe4f 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ValidatorData.java
@@ -18,30 +18,13 @@
  */
 package org.apache.rat.testhelpers.data;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-import org.apache.rat.ConfigurationException;
 import org.apache.rat.ReportConfiguration;
 import org.apache.rat.Reporter;
-import org.apache.rat.api.RatException;
-import org.apache.rat.configuration.XMLConfig;
-import org.apache.rat.configuration.XMLConfigurationWriter;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.report.claim.ClaimStatistic;
-import org.apache.rat.report.xml.writer.XmlWriter;
 import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
-
-import static org.apache.rat.configuration.XMLConfigurationReader.nodeListConsumer;
 
 /**
  * The validator for test data.
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
index df911ad4d..b9ddddfd0 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
@@ -59,7 +59,7 @@ public void run(final RatReport report) throws RatException {
     }
 
     @Override
-    public DocumentName getName() {
+    public DocumentName name() {
         return name;
     }
 }

From e61bcdd0a09af812cc3db9f25e75644c347f3bd5 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 10 May 2026 15:47:37 +0100
Subject: [PATCH 06/36] fixed tests

---
 .../it/java/org/apache/rat/ReportTest.java    |  2 +-
 .../resources/ReportTest/RAT_14/verify.groovy |  4 ++--
 .../apache/rat/testhelpers/BaseOption.java    | 19 ++++++++++++++++++-
 .../rat/testhelpers/BaseOptionCollection.java | 18 ++++++++++++++++++
 4 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java b/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
index b695134a6..027619288 100644
--- a/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
+++ b/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
@@ -142,7 +142,7 @@ public void integrationTest(String testName, Document commandLineDoc) throws Exc
             try {
                 Object value = shell.run(groovyScript, new String[]{outputFile.getAbsolutePath(), logFile.getAbsolutePath()});
                 if (value != null) {
-                    fail(String.format("%s", value));
+                    fail(String.format("%s: %s", testName, value));
                 }
             } catch (AssertionError e) {
                 throw new AssertionError(String.format("%s: %s", testName, e.getMessage()), e);
diff --git a/apache-rat-core/src/it/resources/ReportTest/RAT_14/verify.groovy b/apache-rat-core/src/it/resources/ReportTest/RAT_14/verify.groovy
index 226394df0..c0027ba13 100644
--- a/apache-rat-core/src/it/resources/ReportTest/RAT_14/verify.groovy
+++ b/apache-rat-core/src/it/resources/ReportTest/RAT_14/verify.groovy
@@ -66,9 +66,9 @@ myArgs[3] = src.getAbsolutePath()
 
 ReportConfiguration configuration = OptionCollection.parseCommands(src, myArgs, { opts -> })
 assertNotNull(configuration)
-configuration.validate(DefaultLog.getInstance().&error)
+configuration.validate()
 Reporter reporter = new Reporter(configuration)
-ClaimStatistic statistic = reporter.execute()
+ClaimStatistic statistic = reporter.execute().getStatistic()
 
 assertEquals(3, statistic.getCounter(ClaimStatistic.Counter.APPROVED))
 assertEquals(2, statistic.getCounter(ClaimStatistic.Counter.ARCHIVES))
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
index c6ae379b4..4a22d9d7e 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOption.java
@@ -1,4 +1,21 @@
-
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
 package org.apache.rat.testhelpers;
 
 import org.apache.commons.cli.Option;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
index 615d8a099..18b507103 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
@@ -1,3 +1,21 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
 package org.apache.rat.testhelpers;
 
 import org.apache.commons.cli.Option;

From 90a12f85ffbe4d441f716899708037c40ab3c784 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 24 May 2026 10:34:08 +0100
Subject: [PATCH 07/36] Change to Reporter.Output usage Change to
 ReportConfiguration.IODescriptor usage

---
 .../src/main/java/org/apache/rat/Report.java  |  3 ++-
 .../apache/rat/commandline/StyleSheets.java   |  2 +-
 .../apache/rat/ReporterOptionsProvider.java   | 10 --------
 .../AbstractConfigurationOptionsProvider.java | 13 +++++++---
 .../src/it/RAT-469/invoker.properties         |  2 +-
 .../java/org/apache/rat/mp/RatCheckMojo.java  | 25 +++++++++++--------
 .../java/org/apache/rat/mp/RatReportMojo.java |  7 +++---
 .../org/apache/rat/mp/RatCheckMojoTest.java   |  4 +--
 apache-rat-tasks/pom.xml                      | 19 ++++++++++++++
 .../java/org/apache/rat/anttasks/Report.java  | 18 ++++++-------
 .../org/apache/rat/anttasks/ReportTest.java   |  2 +-
 .../antunit/report-bad-configurations.xml     |  4 +--
 .../test/resources/antunit/report-junit.xml   |  4 +--
 .../test/resources/antunit/stylesheet.xslt    |  2 ++
 .../apache/rat/tools/xsd/XsdGenerator.java    |  2 +-
 15 files changed, 70 insertions(+), 47 deletions(-)
 create mode 100644 apache-rat-tasks/src/test/resources/antunit/stylesheet.xslt

diff --git a/apache-rat-core/src/main/java/org/apache/rat/Report.java b/apache-rat-core/src/main/java/org/apache/rat/Report.java
index 5d9c914f2..ce019b782 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Report.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Report.java
@@ -22,6 +22,7 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.nio.charset.StandardCharsets;
 
 import org.apache.commons.cli.Options;
 import org.apache.commons.io.function.IOSupplier;
@@ -73,7 +74,7 @@ public static void main(final String[] args) throws Exception {
      */
     private static void printUsage(final Options options, final IOSupplier<OutputStream> out) {
         try (OutputStream stream = out.get();
-             PrintWriter writer = new PrintWriter(stream)) {
+             PrintWriter writer = new PrintWriter(stream, false, StandardCharsets.UTF_8)) {
             new Help(writer).printUsage(options);
         } catch (IOException e) {
             throw new RuntimeException(e);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
index f9e47cc2b..2e110a7db 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/StyleSheets.java
@@ -97,7 +97,7 @@ public static ReportConfiguration.IODescriptor<InputStream> getStyleSheet(final
         if (xslt.asFile().exists()) {
             return new ReportConfiguration.IODescriptor<>(xslt.toString(), () -> Files.newInputStream(xslt.asFile().toPath()));
         }
-        throw new ConfigurationException(format("Stylesheet file '%s' not found", name));
+        throw new ConfigurationException(format("Stylesheet file '%s' not found: %s", name, xslt.getName()));
     }
 
     /**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 72d01010c..580543729 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -247,9 +247,7 @@ private void noDefaultsTest(final Option option) {
                 reporter.execute();
                 fail("Should have thrown exception");
             } catch (RatException e) {
-               // ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
                 ClaimValidator validator = config.getClaimValidator();
-              //  assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
             }
         });
     }
@@ -990,10 +988,6 @@ private void listLicenses(final Option option) {
 
         assertDoesNotThrow(() -> {
             configureSourceDir(option);
-//            File outFile = new File(sourceDir, "out.xml");
-//            FileUtils.delete(outFile);
-//            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
-//            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
             for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
                 args[0] = filter.name();
                 ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
@@ -1035,10 +1029,6 @@ private void listFamilies(final Option option) {
 
         assertDoesNotThrow(() -> {
             configureSourceDir(option);
-//            File outFile = new File(sourceDir, "out.xml");
-//            FileUtils.delete(outFile);
-//            ImmutablePair<Option, String[]> outputFile = ImmutablePair.of(Arg.OUTPUT_FILE.option(), new String[]{outFile.getAbsolutePath()});
-//            ImmutablePair<Option, String[]> stylesheet = ImmutablePair.of(Arg.OUTPUT_STYLE.option(), new String[]{StyleSheets.XML.arg()});
             for (LicenseSetFactory.LicenseFilter filter : LicenseSetFactory.LicenseFilter.values()) {
                 args[0] = filter.name();
                 ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index db53fff04..ae46ff2c7 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -862,12 +862,19 @@ private void styleSheetTest(final Option option) {
         // run the test
         String[] args = {null};
         assertDoesNotThrow(() -> {
-            for (String sheet : new String[]{"plain-rat", "missing-headers", "unapproved-licenses", file.getAbsolutePath()}) {
+            for (String sheet : new String[]{"plain-rat", "missing-headers", "unapproved-licenses", "stylesheet-" + option.getLongOpt()}) {
                 args[0] = sheet;
                 ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));
-                try (InputStream expected = StyleSheets.getStyleSheet(sheet, DocumentName.builder(baseDir).build()).ioSupplier().get();
+                DocumentName base = DocumentName.builder(baseDir).build();
+                DocumentName expectedName = base.resolve(sheet);
+                try (InputStream expected = StyleSheets.getStyleSheet(sheet, base).ioSupplier().get();
                      InputStream actual = config.getStyleSheet().get()) {
-                    assertThat(IOUtils.contentEquals(expected, actual)).as(() -> String.format("'%s' does not match", sheet)).isTrue();
+                    String expectedStr =  IOUtils.toString(expected);
+                    String actualStr =  IOUtils.toString(actual);
+                    assertThat(actualStr).isEqualTo(expectedStr).as(() -> String.format("'%s' does not match '%s': %s != %s",
+                            config.getStyleSheetDescriptor().name(),
+                            expectedName.getName(),
+                            actualStr, expectedStr));
                 }
             }
         });
diff --git a/apache-rat-plugin/src/it/RAT-469/invoker.properties b/apache-rat-plugin/src/it/RAT-469/invoker.properties
index 6486eb1de..0e632cdef 100644
--- a/apache-rat-plugin/src/it/RAT-469/invoker.properties
+++ b/apache-rat-plugin/src/it/RAT-469/invoker.properties
@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-invoker.goals = clean apache-rat:rat
+invoker.goals = clean apache-rat:check apache-rat:rat
diff --git a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
index 7bd6b1da0..1cc128b87 100644
--- a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
+++ b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
@@ -36,6 +36,7 @@
 import org.apache.rat.commandline.Arg;
 import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.config.results.ClaimValidator;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.utils.DefaultLog;
@@ -209,11 +210,12 @@ public void execute() throws MojoExecutionException, MojoFailureException {
             }
             try {
                 this.reporter = new Reporter(config);
-                reporter.output();
+                Reporter.Output output = reporter.execute();
                 if (verbose) {
-                    reporter.writeSummary(logWriter);
+                    output.writeSummary(logWriter);
                 }
-                check(config);
+                output.format(config);
+                check(output);
             } catch (MojoFailureException e) {
                 throw e;
             } catch (Exception e) {
@@ -224,17 +226,18 @@ public void execute() throws MojoExecutionException, MojoFailureException {
         }
     }
 
-    protected void check(final ReportConfiguration config) throws MojoFailureException {
-        ClaimStatistic statistics = reporter.getClaimsStatistic();
+    protected void check(final Reporter.Output output) throws MojoFailureException {
+        ClaimStatistic statistics = output.getStatistic();
+        ClaimValidator validator = output.getConfiguration().getClaimValidator();
         try {
-           reporter.writeSummary(DefaultLog.getInstance().asWriter(Log.Level.DEBUG));
-           if (config.getClaimValidator().hasErrors()) {
-               config.getClaimValidator().logIssues(statistics);
+           output.writeSummary(DefaultLog.getInstance().asWriter(Log.Level.DEBUG));
+           if (validator.hasErrors()) {
+               validator.logIssues(statistics);
                if (consoleOutput &&
-                       !config.getClaimValidator().isValid(ClaimStatistic.Counter.UNAPPROVED, statistics.getCounter(ClaimStatistic.Counter.UNAPPROVED))) {
+                       !validator.isValid(ClaimStatistic.Counter.UNAPPROVED, statistics.getCounter(ClaimStatistic.Counter.UNAPPROVED))) {
                    try {
                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-                       reporter.output(StyleSheets.UNAPPROVED_LICENSES.getStyleSheet(), () -> baos);
+                       output.format(StyleSheets.UNAPPROVED_LICENSES.getStyleSheet().ioSupplier(), () -> baos);
                        getLog().warn(baos.toString(StandardCharsets.UTF_8));
                    } catch (RuntimeException rte) {
                        throw rte;
@@ -244,7 +247,7 @@ protected void check(final ReportConfiguration config) throws MojoFailureExcepti
                }
 
                String msg = format("Counter(s) %s exceeded minimum or maximum values. See RAT report in: '%s'.",
-                       String.join(", ", config.getClaimValidator().listIssues(statistics)),
+                       String.join(", ", validator.listIssues(statistics)),
                        getRatTxtFile());
 
                if (!ignoreErrors) {
diff --git a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatReportMojo.java b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatReportMojo.java
index 330d3c5e1..a367c1de9 100644
--- a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatReportMojo.java
+++ b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatReportMojo.java
@@ -446,11 +446,12 @@ protected void executeReport(final Locale locale) throws MavenReportException {
                     config.reportExclusions(logWriter);
                 }
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
-                config.setOut(() -> baos);
+                config.setOut(new ReportConfiguration.IODescriptor<>("streaming output", () -> baos));
                 Reporter reporter = new Reporter(config);
-                reporter.output();
+                Reporter.Output output = reporter.execute();
+                output.format(config);
                 if (verbose) {
-                    reporter.writeSummary(logWriter);
+                    output.writeSummary(logWriter);
                 }
                 sink.text(baos.toString(StandardCharsets.UTF_8.name()));
             } catch (IOException | MojoExecutionException | RatException e) {
diff --git a/apache-rat-plugin/src/test/java/org/apache/rat/mp/RatCheckMojoTest.java b/apache-rat-plugin/src/test/java/org/apache/rat/mp/RatCheckMojoTest.java
index 5734ab73e..3013df2ac 100644
--- a/apache-rat-plugin/src/test/java/org/apache/rat/mp/RatCheckMojoTest.java
+++ b/apache-rat-plugin/src/test/java/org/apache/rat/mp/RatCheckMojoTest.java
@@ -247,7 +247,7 @@ void it5() throws Exception {
         assertThat(config.isAddingLicenses()).as("Should not be adding licenses").isFalse();
         assertThat(config.isAddingLicensesForced()).as("Should not be forcing licenses").isFalse();
 
-        ReportConfigurationTest.validateDefaultApprovedLicenses(config, 1);
+        ReportConfigurationTest.validateDefaultApprovedLicenses(config, "CC-BY-NC-ND");
         assertThat(config.getLicenseCategories(LicenseFilter.APPROVED)).doesNotContain(ILicenseFamily.makeCategory("YAL"))
                 .contains(ILicenseFamily.makeCategory("CC"));
         ReportConfigurationTest.validateDefaultLicenseFamilies(config, "YAL", "CC");
@@ -332,7 +332,7 @@ void rat343() throws Exception {
         assertThat(config.getCopyrightMessage()).isNull();
         assertThat(config.getStyleSheet()).withFailMessage("Stylesheet should not be null").isNotNull();
 
-        ReportConfigurationTest.validateDefaultApprovedLicenses(config, 1);
+        ReportConfigurationTest.validateDefaultApprovedLicenses(config, "BSD");
         ReportConfigurationTest.validateDefaultLicenseFamilies(config, "BSD", "CC BY");
         ReportConfigurationTest.validateDefaultLicenses(config, "BSD", "CC BY");
 
diff --git a/apache-rat-tasks/pom.xml b/apache-rat-tasks/pom.xml
index aca9d90b7..312d9f160 100644
--- a/apache-rat-tasks/pom.xml
+++ b/apache-rat-tasks/pom.xml
@@ -188,6 +188,25 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-antrun-plugin</artifactId>
+        <configuration>
+          <skip>${skipTests}</skip>
+          <target>
+            <ant antfile="src/test/resources/antunit/report-bad-configurations.xml" inheritAll="false" inheritRefs="false">
+              <property name="jar.name" location="${project.build.outputDirectory}"/>
+              <property name="base.dir" location="${basedir}"/>
+              <property name="antunit.jar.name" location="${project.build.directory}/dependencies/ant-antunit.jar"/>
+              <property name="test.skipped" value="${skipTests}"/>
+              <property name="test.classpath" refid="maven.test.classpath"/>
+            </ant>
+            <ant antfile="src/test/resources/antunit/report-normal-operation.xml" inheritAll="false" inheritRefs="false">
+              <property name="jar.name" location="${project.build.outputDirectory}"/>
+              <property name="base.dir" location="${basedir}"/>
+              <property name="antunit.jar.name" location="${project.build.directory}/dependencies/ant-antunit.jar"/>
+              <property name="test.skipped" value="${maven.test.skip}"/>
+              <property name="test.classpath" refid="maven.test.classpath"/>
+            </ant>
+          </target>
+        </configuration>
         <executions>
           <execution>
             <phase>test</phase>
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
index a069084f2..80ac5dcef 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
@@ -29,7 +29,6 @@
 
 import org.apache.commons.cli.Option;
 import org.apache.commons.io.filefilter.IOFileFilter;
-import org.apache.commons.io.output.CloseShieldOutputStream;
 import org.apache.rat.ConfigurationException;
 import org.apache.rat.DeprecationReporter;
 import org.apache.rat.ImplementationException;
@@ -411,14 +410,15 @@ public ReportConfiguration getConfiguration() {
         try {
             boolean helpLicenses = !getValues(Arg.HELP_LICENSES).isEmpty();
             removeKey(Arg.HELP_LICENSES);
-
-            final ReportConfiguration configuration = OptionCollection.parseCommands(new File("."), args().toArray(new String[0]),
+            File antFileDir = new File(getProject().getProperty("ant.file")).getParentFile();
+            DocumentName name = DocumentName.builder(antFileDir).build();;
+            final ReportConfiguration configuration = OptionCollection.parseCommands(antFileDir, args().toArray(new String[0]),
                     o -> DefaultLog.getInstance().warn("Help option not supported"),
                     true);
             if (getValues(Arg.OUTPUT_FILE).isEmpty()) {
-                configuration.setOut(() -> new LogOutputStream(this, Project.MSG_INFO));
+                configuration.setOut(new ReportConfiguration.IODescriptor<>("log output", () -> new LogOutputStream(this, Project.MSG_INFO)));
             }
-            DocumentName name = DocumentName.builder(getProject().getBaseDir()).build();
+
             configuration.addSource(new ResourceCollectionContainer(name, configuration, nestedResources));
             configuration.addApprovedLicenseCategories(deprecatedConfig.approvedLicenseCategories);
             configuration.removeApprovedLicenseCategories(deprecatedConfig.removedLicenseCategories);
@@ -443,9 +443,9 @@ public ReportConfiguration getConfiguration() {
     @Override
     public void execute() {
         try {
-            Reporter r = new Reporter(validate(getConfiguration()));
-            r.output(StyleSheets.PLAIN.getStyleSheet(), () -> CloseShieldOutputStream.wrap(System.out));
-            r.output();
+            Reporter.Output output = new Reporter(validate(getConfiguration())).execute();
+            output.format(StyleSheets.PLAIN.getStyleSheet().ioSupplier(), ReportConfiguration.SYSTEM_OUT.ioSupplier());
+            output.format(output.getConfiguration());
         } catch (BuildException e) {
             throw e;
         } catch (Exception ioex) {
@@ -458,7 +458,7 @@ public void execute() {
      */
     protected ReportConfiguration validate(final ReportConfiguration cfg) {
         try {
-            cfg.validate(s -> log(s, Project.MSG_WARN));
+            cfg.validate();
         } catch (ConfigurationException e) {
             throw new BuildException(e.getMessage(), e.getCause());
         }
diff --git a/apache-rat-tasks/src/test/java/org/apache/rat/anttasks/ReportTest.java b/apache-rat-tasks/src/test/java/org/apache/rat/anttasks/ReportTest.java
index ad44dda17..e4ecdc6f2 100644
--- a/apache-rat-tasks/src/test/java/org/apache/rat/anttasks/ReportTest.java
+++ b/apache-rat-tasks/src/test/java/org/apache/rat/anttasks/ReportTest.java
@@ -198,7 +198,7 @@ public void testNoLicenseMatchers() {
             buildRule.executeTarget("testNoLicenseMatchers");
             fail("Expected Exception");
         } catch (BuildException e) {
-            final String expect = "at least one license";
+            final String expect = "At least one license";
             assertThat(e.getMessage()).describedAs("Expected " + expect).contains(expect);
         }
     }
diff --git a/apache-rat-tasks/src/test/resources/antunit/report-bad-configurations.xml b/apache-rat-tasks/src/test/resources/antunit/report-bad-configurations.xml
index 56d1e8d7a..bf43ff943 100644
--- a/apache-rat-tasks/src/test/resources/antunit/report-bad-configurations.xml
+++ b/apache-rat-tasks/src/test/resources/antunit/report-bad-configurations.xml
@@ -31,7 +31,7 @@
 
   <taskdef uri="antlib:org.apache.rat.anttasks" resource="org/apache/rat/anttasks/antlib.xml">
     <classpath>
-      <pathelement location="${jar.name}" />
+        <pathelement location="${jar.name}" />
       <pathelement path='${test.classpath}' />
     </classpath>
   </taskdef>
@@ -50,7 +50,7 @@
   </target>
 
   <target name="testNoLicenseMatchers">
-    <au:expectfailure expectedMessage="at least one license">
+    <au:expectfailure expectedMessage="At least one license">
       <rat:report useDefaultLicenses="false">
         <file file="${ant.file}"/>
       </rat:report>
diff --git a/apache-rat-tasks/src/test/resources/antunit/report-junit.xml b/apache-rat-tasks/src/test/resources/antunit/report-junit.xml
index 81827d40f..3b64f5356 100644
--- a/apache-rat-tasks/src/test/resources/antunit/report-junit.xml
+++ b/apache-rat-tasks/src/test/resources/antunit/report-junit.xml
@@ -226,7 +226,7 @@ public class InlineMatcher extends AbstractHeaderMatcher {
 		<file file="${ant.file}"/>
 		<rat:report>
 			<rat:stylesheet>
-				<file file="${ant.file}"/>
+				<file file="stylesheet.xslt"/>
 			</rat:stylesheet>
 		</rat:report>
 	</target>
@@ -235,7 +235,7 @@ public class InlineMatcher extends AbstractHeaderMatcher {
 		<file file="${ant.file}"/>
 		<rat:report>
 			<rat:stylesheet>
-				<file file="${ant.file}"/>
+				<file file="stylesheet.xslt"/>
 			</rat:stylesheet>
 		</rat:report>
 	</target>
diff --git a/apache-rat-tasks/src/test/resources/antunit/stylesheet.xslt b/apache-rat-tasks/src/test/resources/antunit/stylesheet.xslt
new file mode 100644
index 000000000..008412298
--- /dev/null
+++ b/apache-rat-tasks/src/test/resources/antunit/stylesheet.xslt
@@ -0,0 +1,2 @@
+The text to match
+more text to match
\ No newline at end of file
diff --git a/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java b/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
index a3ceb01c4..68437fed6 100644
--- a/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
+++ b/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
@@ -71,7 +71,7 @@ public static void main(final String[] args) throws IOException, TransformerExce
         XsdGenerator generator = new XsdGenerator();
 
         try (InputStream in = generator.getInputStream();
-             InputStream styleIn = StyleSheets.XML.getStyleSheet().get()) {
+             InputStream styleIn = StyleSheets.XML.getStyleSheet().ioSupplier().get()) {
             Transformer transformer = StandardXmlFactory.create(styleIn);
             transformer.transform(new StreamSource(in),
                     new StreamResult(new OutputStreamWriter(System.out, StandardCharsets.UTF_8)));

From b9e995508407ffb03310194cdb8f2597fc31e32c Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 24 May 2026 10:57:02 +0100
Subject: [PATCH 08/36] updated javadoc

---
 .../apache/rat/testhelpers/data/ReportTestDataProvider.java    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
index 399ed50d9..4b50a8d9d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
@@ -70,8 +70,7 @@
  * Generates a list of TestData for executing the Report.
  * Use of this interface ensures consistent testing across the UIs. Each method
  * tests an Option from {@link OptionCollectionParser} that must be implemented in the UI.
- * This differes from the {@link OptionTestDataProvider} in that tests from this set
- * expect that execptions will be thrown during execution, and tests the xml output.
+ * These tests generally validate the results in the generated XML are as expected.
  */
 public class ReportTestDataProvider extends AbstractTestDataProvider {
 

From fc994116dd5d1f3c6283e6dd6a629ad2f73eda43 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sun, 31 May 2026 11:42:48 +0100
Subject: [PATCH 09/36] updated UI strategy

---
 src/site/markdown/development/ui_implementation.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/site/markdown/development/ui_implementation.md b/src/site/markdown/development/ui_implementation.md
index c70733ab3..cf6a35f69 100644
--- a/src/site/markdown/development/ui_implementation.md
+++ b/src/site/markdown/development/ui_implementation.md
@@ -20,6 +20,12 @@
 
 The RAT architecture supports multiple UIs. By default, RAT provides a command line implementation (CLI) as well as implementations for the Ant and Maven build system. The source code for those implementation provide a good roadmap for implementing any new UI.
 
+Our UI strategy is for core to provide basic functionality to process an Apache Commons CLI definition and arguments.  UIs will process input as per their style and standards, translate those input into RAT UI options and arguments.  These are used to create a `ReportConfiguration`.  The `ReportConfiguration` is the constructor argument for a RAT `Reporter` which is executed and the resulting `Reporter.Output` used to update the UI as necessary.
+
+In addition, RAT provides a collection of `TestData` objects which define tests that the UI must pass.  Each `TestData` provides a unique name for the test, the command line that should be created from the UI, a funstion to create the test directory and contents setup. and a validator to validate the results.
+
+Implementors are expected to create a directory, call the setup to populate it with the test data, process the commandLine to create a UI specific equivalent, execute the `Reporter` using a configuration generated by the UI and then verify the `Reporter.Output` using  the `TestData` validator.
+
 ### CLI first
 
 RAT is designed as a CLI first architecture. This means that every new functionality is introduced as a CLI option first. All tests cases are built and the implementation verified before it is released. Additional native UIs are build on top of the CLI implementation. 

From 1a9e1bce6b551164d793529c537ebc2c3aafa343 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 13:33:45 +0100
Subject: [PATCH 10/36] Remove ArchiveEntryDocument and clean up ArchiveWalker.

---
 .../rat/document/ArchiveEntryDocument.java    | 62 -------------------
 .../org/apache/rat/walker/ArchiveWalker.java  | 29 +++++++--
 2 files changed, 24 insertions(+), 67 deletions(-)
 delete mode 100644 apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java

diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java b/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java
deleted file mode 100644
index dabc848bc..000000000
--- a/apache-rat-core/src/main/java/org/apache/rat/document/ArchiveEntryDocument.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one   *
- * or more contributor license agreements.  See the NOTICE file *
- * distributed with this work for additional information        *
- * regarding copyright ownership.  The ASF licenses this file   *
- * to you under the Apache License, Version 2.0 (the            *
- * "License"); you may not use this file except in compliance   *
- * with the License.  You may obtain a copy of the License at   *
- *                                                              *
- *   http://www.apache.org/licenses/LICENSE-2.0                 *
- *                                                              *
- * Unless required by applicable law or agreed to in writing,   *
- * software distributed under the License is distributed on an  *
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
- * KIND, either express or implied.  See the License for the    *
- * specific language governing permissions and limitations      *
- * under the License.                                           *
- */
-
-package org.apache.rat.document;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.SortedSet;
-
-import org.apache.rat.api.Document;
-
-/**
- * A Document that wraps an Archive entry.
- */
-public class ArchiveEntryDocument extends Document {
-
-    /** The contents of the entry */
-    private final byte[] contents;
-
-    /**
-     * Creates an Archive entry.
-     * @param entryName the name of this entry from outside the archive.
-     * @param contents the contents of the entry.
-     * @param nameMatcher the name matcher to filter contents with.
-     */
-    public ArchiveEntryDocument(final ArchiveEntryName entryName, final byte[] contents, final DocumentNameMatcher nameMatcher) {
-        super(entryName, nameMatcher);
-        this.contents = contents;
-    }
-
-    @Override
-    public InputStream inputStream() {
-        return new ByteArrayInputStream(contents);
-    }
-
-    @Override
-    public boolean isDirectory() {
-        return false;
-    }
-
-    @Override
-    public SortedSet<Document> listChildren() {
-        return Collections.emptySortedSet();
-    }
-}
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
index a50aa5ef8..4ad410449 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/ArchiveWalker.java
@@ -20,12 +20,15 @@
 package org.apache.rat.walker;
 
 import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.SortedSet;
 
 import org.apache.commons.compress.archivers.ArchiveEntry;
 import org.apache.commons.compress.archivers.ArchiveException;
@@ -34,9 +37,9 @@
 import org.apache.commons.io.IOUtils;
 import org.apache.rat.api.Document;
 import org.apache.rat.api.RatException;
-import org.apache.rat.document.ArchiveEntryDocument;
 import org.apache.rat.document.ArchiveEntryName;
 import org.apache.rat.document.DocumentName;
+import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.utils.DefaultLog;
 
@@ -87,13 +90,29 @@ public Collection<Document> getDocuments() throws RatException {
             ArchiveEntry entry;
             while ((entry = input.getNextEntry()) != null) {
                 if (!entry.isDirectory() && input.canReadEntryData(entry)) {
-                    DocumentName innerName = DocumentName.builder().setName(entry.getName())
+                    final DocumentName innerName = DocumentName.builder().setName(entry.getName())
                             .setBaseName(".").build();
-                    if (this.getDocument().getNameMatcher().matches(innerName)) {
+                    final DocumentNameMatcher documentNameMatcher = getDocument().getNameMatcher();
+                    if (documentNameMatcher.matches(innerName)) {
+                        ArchiveEntryName entryName = new ArchiveEntryName(getDocument().getName(), entry.getName());
                         ByteArrayOutputStream baos = new ByteArrayOutputStream();
                         IOUtils.copy(input, baos);
-                        ArchiveEntryName entryName = new ArchiveEntryName(getDocument().getName(), entry.getName());
-                        result.add(new ArchiveEntryDocument(entryName, baos.toByteArray(), getDocument().getNameMatcher()));
+                        result.add(new Document(entryName, documentNameMatcher) {
+                            @Override
+                            public InputStream inputStream() {
+                                return new ByteArrayInputStream(baos.toByteArray());
+                            }
+
+                            @Override
+                            public boolean isDirectory() {
+                                return false;
+                            }
+
+                            @Override
+                            public SortedSet<Document> listChildren() {
+                                return Collections.emptySortedSet();
+                            }
+                        });
                     }
                 }
             }

From 335541220b189a6e0464b60dbab4c8ea262168cd Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 13:35:54 +0100
Subject: [PATCH 11/36] Change ArgumentContext to build from Options and
 arguments rather than CommandLine

---
 .../java/org/apache/rat/OptionCollection.java | 14 ++++----------
 .../apache/rat/OptionCollectionParser.java    |  6 ++----
 .../rat/commandline/ArgumentContext.java      | 19 +++++++++++++------
 .../org/apache/rat/OptionCollectionTest.java  |  3 +--
 4 files changed, 20 insertions(+), 22 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
index d04398080..65706862e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
@@ -34,7 +34,6 @@
 import java.util.stream.Collectors;
 
 import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
 import org.apache.commons.cli.Option;
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
@@ -131,27 +130,22 @@ public static ReportConfiguration parseCommands(final File workingDirectory, fin
                                                     final Consumer<Options> helpCmd, final boolean noArgs) throws IOException {
 
         Options opts = buildOptions();
-        CommandLine commandLine;
+            ArgumentContext argumentContext;
         try {
-            commandLine = DefaultParser.builder().setDeprecatedHandler(DeprecationReporter.getLogReporter())
-                    .setAllowPartialMatching(true).build().parse(opts, args);
+            argumentContext = new ArgumentContext(workingDirectory, opts, args);
         } catch (ParseException e) {
-            DefaultLog.getInstance().error(e.getMessage());
-            DefaultLog.getInstance().error("Please use the \"--help\" option to see a list of valid commands and options.", e);
             System.exit(1);
             return null; // dummy return (won't be reached) to avoid Eclipse complaint about possible NPE
             // for "commandLine"
         }
-
-        ArgumentContext argumentContext = new ArgumentContext(workingDirectory, commandLine);
         Arg.processLogLevel(argumentContext, CLIOptionCollection.INSTANCE);
 
-        if (commandLine.hasOption(HELP)) {
+        if (argumentContext.getCommandLine().hasOption(HELP)) {
             helpCmd.accept(opts);
             return null;
         }
 
-        if (commandLine.hasOption(Arg.HELP_LICENSES.option())) {
+        if (argumentContext.getCommandLine().hasOption(Arg.HELP_LICENSES.option())) {
             new Licenses(createConfiguration(argumentContext), new PrintWriter(System.out, false, StandardCharsets.UTF_8)).printHelp();
             return null;
         }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
index d40686c60..db75e3eec 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
@@ -76,8 +76,7 @@ public ArgumentContext parseCommands(final File workingDirectory, final String[]
      * @return the CommandLine
      * @throws ParseException on option parsing error.
      */
-    //@VisibleForTesting
-    CommandLine parseCommandLine(final Options opts, final String[] args) throws ParseException {
+    public static CommandLine parseCommandLine(final Options opts, final String[] args) throws ParseException {
         try {
             return DefaultParser.builder().setDeprecatedHandler(DeprecationReporter.getLogReporter())
                     .setAllowPartialMatching(true).build().parse(opts, args);
@@ -100,8 +99,7 @@ CommandLine parseCommandLine(final Options opts, final String[] args) throws Par
      */
     private ArgumentContext parseCommands(final File workingDirectory, final String[] args,
                                                                        final Options options) throws IOException, ParseException {
-        CommandLine commandLine = parseCommandLine(options, args);
-        ArgumentContext argumentContext = new ArgumentContext(workingDirectory, commandLine);
+        ArgumentContext argumentContext = new ArgumentContext(workingDirectory, options, args);
         Arg.processLogLevel(argumentContext, uiOptionCollection);
         populateConfiguration(argumentContext);
         if (uiOptionCollection.isSelected(Arg.HELP_LICENSES)) {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/ArgumentContext.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/ArgumentContext.java
index d4374a57b..49917397d 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/ArgumentContext.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/ArgumentContext.java
@@ -22,7 +22,9 @@
 
 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
+import org.apache.rat.OptionCollectionParser;
 import org.apache.rat.ReportConfiguration;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.ui.UIOptionCollection;
@@ -46,21 +48,26 @@ public final class ArgumentContext {
      * Creates a context with the specified configuration.
      * @param workingDirectory the directory from which relative file names will be resolved.
      * @param configuration The configuration that is being built.
-     * @param commandLine The command line that is building the configuration.
+     * @param opts the Options for the command line.
+     * @param args the arguments for the options.
+     * @throws ParseException if the options can not parse the arguments.
      */
-    public ArgumentContext(final File workingDirectory, final ReportConfiguration configuration, final CommandLine commandLine) {
+    public ArgumentContext(final File workingDirectory, final ReportConfiguration configuration, final Options opts, final String[] args)
+            throws ParseException {
         this.workingDirectory = DocumentName.builder(workingDirectory).build();
-        this.commandLine = commandLine;
+        this.commandLine = OptionCollectionParser.parseCommandLine(opts, args);
         this.configuration = configuration;
     }
 
     /**
      * Creates a context with an empty configuration.
      * @param workingDirectory The directory from which to resolve relative file names.
-     * @param commandLine The command line.
+     * @param opts the Options for the command line.
+     * @param args the arguments for the options.
+     * @throws ParseException if the options can not parse the arguments.
      */
-    public ArgumentContext(final File workingDirectory, final CommandLine commandLine) {
-        this(workingDirectory, new ReportConfiguration(), commandLine);
+    public ArgumentContext(final File workingDirectory, final Options opts, final String[] args) throws ParseException {
+        this(workingDirectory, new ReportConfiguration(), opts, args);
     }
 
     /**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
index 86f58c325..9832095f5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
@@ -220,8 +220,7 @@ public void testShortenedOptions() throws IOException {
     @Test
     public void testDefaultConfiguration() throws ParseException {
         String[] empty = {};
-        CommandLine cl = new DefaultParser().parse(OptionCollection.buildOptions(), empty);
-        ArgumentContext context = new ArgumentContext(new File("."), cl);
+        ArgumentContext context = new ArgumentContext(new File("."), OptionCollection.buildOptions(), empty);
         ReportConfiguration config = OptionCollection.createConfiguration(context);
         ReportConfigurationTest.validateDefault(config);
     }

From b028db26a311ee0d5ca0d44a4c2efc389f3db9d4 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 13:49:11 +0100
Subject: [PATCH 12/36] Switch to UnmodifiableSets for licences

---
 .../org/apache/rat/ReportConfiguration.java   | 22 ++++++++++++++++++-
 .../apache/rat/analysis/AnalyserFactory.java  |  9 ++++----
 .../java/org/apache/rat/DefaultsTest.java     |  3 ++-
 .../rat/documentation/velocity/RatTool.java   |  9 ++++----
 4 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index 82ce49204..f6b2ccf7c 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -42,6 +42,7 @@
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.io.output.CloseShieldOutputStream;
 import org.apache.commons.lang3.StringUtils;
@@ -74,6 +75,8 @@
 import org.w3c.dom.Node;
 import org.xml.sax.SAXException;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * A configuration object is used by the front end to invoke the
  * {@link Reporter}. The sole purpose of the frontends is to create the
@@ -706,7 +709,7 @@ public SortedSet<String> getLicenseCategories(final LicenseFilter filter) {
      * @param filter The LicenseFilter to filter the licenses by.
      * @return the Sorted set of approved license categories.
      */
-    public SortedSet<ILicense> getLicenses(final LicenseFilter filter) {
+    public UnmodifiableSortedSet<ILicense> getLicenses(final LicenseFilter filter) {
         return licenseSetFactory.getLicenses(filter);
     }
 
@@ -873,6 +876,12 @@ public void validate() {
         licenseSetFactory.validate();
     }
 
+    /**
+     * Serializes the ReportConfiguration into an XML document that can be deserialzed by the Serde.
+     * Deserialized ReportConfigurations can not be executed as the reportable objects a simply named placeholders
+     * and do not have access to the original object.
+     */
+    @SuppressFBWarnings({"MALICIOUS_XSLT", "XXE_DOCUMENT"})
     public class Serde {
         /**
          * Writes the configuration as an XML document to the appendable.
@@ -966,6 +975,7 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final
                 addSource(new File(nAttributes.get("name")));
             });
 
+            // Deserialize the reportables.
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("reportable"), lNode -> {
                 Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
                 DocumentName documentName = DocumentName.builder().setBaseName(nAttributes.get("baseName"))
@@ -984,6 +994,10 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final
         }
     }
 
+    /**
+     * A record that identifies a deserialized reportable.  Deserialized reportables are not executable.
+     * @param name the name of the reportable.
+     */
     private record DeserializedReportable(DocumentName name) implements IReportable {
         @Override
         public void run(final RatReport report) throws RatException {
@@ -991,6 +1005,12 @@ public void run(final RatReport report) throws RatException {
         }
     }
 
+    /**
+     * An IODescriptor comprises a name and an IOSupplier.  The name should identify the contents of the stream.
+     * @param name the name of the supplier.
+     * @param ioSupplier the IOSupplier that provides either an InputStream or an OutputStream
+     * @param <T> either InputStream or OutputStream.
+     */
     public record IODescriptor<T>(String name, IOSupplier<T> ioSupplier) {
         /**
          * Creates an output IODescriptor for the file name within the working directory.
diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/AnalyserFactory.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/AnalyserFactory.java
index f2eca190d..14a7dc84e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/AnalyserFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/AnalyserFactory.java
@@ -18,10 +18,9 @@
  */
 package org.apache.rat.analysis;
 
-import java.util.Collection;
-import java.util.Set;
 import java.util.function.Predicate;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.ConfigurationException;
 import org.apache.rat.Defaults;
 import org.apache.rat.ReportConfiguration;
@@ -80,7 +79,7 @@ public static DocumentAnalyser createMultiplexer(final DocumentAnalyser... analy
      */
     public static DocumentAnalyser createConfiguredAnalyser(final ReportConfiguration configuration) {
         LicenseSetFactory licenseSetFactory = configuration.getLicenseSetFactory();
-        Set<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
+        UnmodifiableSortedSet<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
         if (licenses.isEmpty()) {
             throw new ConfigurationException("At least one license must be defined");
         }
@@ -98,7 +97,7 @@ public static DocumentAnalyser createConfiguredAnalyser(final ReportConfiguratio
     private static final class DefaultAnalyser implements DocumentAnalyser {
 
         /** The licenses to analyze */
-        private final Collection<ILicense> licenses;
+        private final UnmodifiableSortedSet<ILicense> licenses;
         /** the Report Configuration */
         private final ReportConfiguration configuration;
         /** The matcher for generated files */
@@ -109,7 +108,7 @@ private static final class DefaultAnalyser implements DocumentAnalyser {
          * @param config the ReportConfiguration
          * @param licenses The licenses to analyse
          */
-        DefaultAnalyser(final ReportConfiguration config, final Collection<ILicense> licenses) {
+        DefaultAnalyser(final ReportConfiguration config, final UnmodifiableSortedSet<ILicense> licenses) {
             this.licenses = licenses;
             this.configuration = config;
             this.generatedMatcher = configuration.getGeneratedMatcher();
diff --git a/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java b/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
index bfd5f31e7..db9edb03f 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/DefaultsTest.java
@@ -22,6 +22,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.license.ILicense;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
 import org.junit.jupiter.api.Test;
@@ -36,7 +37,7 @@ public class DefaultsTest {
     public void defaultConfigTest() {
         Defaults defaults = Defaults.builder().build();
 
-        Set<ILicense> licenses = defaults.getLicenseSetFactory().getLicenses(LicenseFilter.ALL);
+        UnmodifiableSortedSet<ILicense> licenses = defaults.getLicenseSetFactory().getLicenses(LicenseFilter.ALL);
 
         Set<String> names = new TreeSet<>();
         licenses.forEach(x -> names.add(x.getLicenseFamily().getFamilyCategory()));
diff --git a/apache-rat-tools/src/main/java/org/apache/rat/documentation/velocity/RatTool.java b/apache-rat-tools/src/main/java/org/apache/rat/documentation/velocity/RatTool.java
index 820e246ea..ca1adadfd 100644
--- a/apache-rat-tools/src/main/java/org/apache/rat/documentation/velocity/RatTool.java
+++ b/apache-rat-tools/src/main/java/org/apache/rat/documentation/velocity/RatTool.java
@@ -24,11 +24,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
 import org.apache.commons.cli.Option;
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.rat.CLIOption;
 import org.apache.rat.CLIOptionCollection;
@@ -187,9 +187,8 @@ public List<EnvVar> environmentVariables() {
      * @return the set of Matchers.
      */
     public Set<Matcher> matchers() {
-        MatcherBuilderTracker tracker = MatcherBuilderTracker.instance();
         Set<Matcher> documentationSet = new TreeSet<>(Comparator.comparing(Matcher::getName));
-        for (Class<?> clazz : tracker.getClasses()) {
+        for (Class<?> clazz : MatcherBuilderTracker.instance().getClasses()) {
             Description desc = DescriptionBuilder.buildMap(clazz);
             documentationSet.add(new Matcher(desc, null));
         }
@@ -246,7 +245,7 @@ public String doubleLine() {
      * @return a list of license property descriptions.
      */
     public List<Description> licenseProperties() {
-        SortedSet<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
+        UnmodifiableSortedSet<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
         Description licenseDescription = DescriptionBuilder.build(licenses.first());
         List<Description> descriptions = new ArrayList<>(licenseDescription.filterChildren(d -> d.getType() == ComponentType.PARAMETER));
         descriptions.sort(Comparator.comparing(Description::getCommonName));
@@ -258,7 +257,7 @@ public List<Description> licenseProperties() {
      * @return the list of defined licenses.
      */
     public List<License> licenses() {
-        Set<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
+        UnmodifiableSortedSet<ILicense> licenses = licenseSetFactory.getLicenses(LicenseSetFactory.LicenseFilter.ALL);
         return licenses.stream().map(License::new).collect(Collectors.toList());
     }
 

From 9b901215c8e337e10c91079634731ff56b60c32c Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 13:55:33 +0100
Subject: [PATCH 13/36] Switch to UnmodifiableSets for licences

---
 .../rat/analysis/DocumentHeaderAnalyser.java      |  6 +++---
 .../apache/rat/analysis/HeaderCheckWorker.java    |  8 +++++---
 .../org/apache/rat/license/LicenseSetFactory.java | 14 +++++++++-----
 .../rat/analysis/HeaderCheckWorkerTest.java       | 15 +++++++++++++--
 4 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/DocumentHeaderAnalyser.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/DocumentHeaderAnalyser.java
index cec174f6f..3f99b7f87 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/DocumentHeaderAnalyser.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/DocumentHeaderAnalyser.java
@@ -20,8 +20,8 @@
 
 import java.io.IOException;
 import java.io.Reader;
-import java.util.Collection;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.api.Document;
 import org.apache.rat.document.DocumentAnalyser;
 import org.apache.rat.license.ILicense;
@@ -35,7 +35,7 @@
 class DocumentHeaderAnalyser implements DocumentAnalyser {
 
     /** The license to analyse */
-    private final Collection<ILicense> licenses;
+    private final UnmodifiableSortedSet<ILicense> licenses;
     /** The matcher for generated headers */
     private final IHeaderMatcher generatedMatcher;
 
@@ -43,7 +43,7 @@ class DocumentHeaderAnalyser implements DocumentAnalyser {
      * Constructs the HeaderAnalyser for the specific license.
      * @param licenses The licenses to analyse
      */
-    DocumentHeaderAnalyser(final IHeaderMatcher generatedMatcher, final Collection<ILicense> licenses) {
+    DocumentHeaderAnalyser(final IHeaderMatcher generatedMatcher, final UnmodifiableSortedSet<ILicense> licenses) {
         super();
         this.generatedMatcher = generatedMatcher;
         this.licenses = licenses;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
index 30243bb07..d4ae8d888 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
@@ -21,10 +21,12 @@
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Locale;
 import java.util.Objects;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.ConfigurationException;
 import org.apache.rat.analysis.matchers.FullTextMatcher;
 import org.apache.rat.api.Document;
@@ -54,7 +56,7 @@ public final class HeaderCheckWorker {
     /** The BufferedReader used to read the lines */
     private final BufferedReader reader;
     /** The licenses to check for match */
-    private final Collection<ILicense> licenses;
+    private final UnmodifiableSortedSet<ILicense> licenses;
     /** The document being processed */
     private final Document document;
     /**  The matcher for generated headers */
@@ -108,7 +110,7 @@ public String toString() {
      * @param licenses The licenses to check against. Not null.
      * @param name The document that is being checked. Possibly null.
      */
-    public HeaderCheckWorker(final IHeaderMatcher generatedMatcher, final Reader reader, final Collection<ILicense> licenses, final Document name) {
+    public HeaderCheckWorker(final IHeaderMatcher generatedMatcher, final Reader reader, final UnmodifiableSortedSet<ILicense> licenses, final Document name) {
         this(generatedMatcher, reader, DEFAULT_NUMBER_OF_RETAINED_HEADER_LINES, licenses, name);
     }
 
@@ -123,7 +125,7 @@ public HeaderCheckWorker(final IHeaderMatcher generatedMatcher, final Reader rea
      * @param document The document that is being checked. Possibly null.
      */
     public HeaderCheckWorker(final IHeaderMatcher generatedMatcher, final Reader reader,
-                             final int numberOfRetainedHeaderLine, final Collection<ILicense> licenses,
+                             final int numberOfRetainedHeaderLine, final UnmodifiableSortedSet<ILicense> licenses,
                              final Document document) {
         Objects.requireNonNull(reader, "Reader may not be null");
         Objects.requireNonNull(licenses, "Licenses may not be null");
diff --git a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
index 07f278918..8da3b193e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
@@ -28,6 +28,7 @@
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.ConfigurationException;
 import org.apache.rat.analysis.IHeaderMatcher;
 import org.apache.rat.analysis.IHeaders;
@@ -319,18 +320,21 @@ public Predicate<ILicense> getApprovedLicensePredicate() {
      * @param filter the types of LicenseFamily objects to return.
      * @return a SortedSet of ILicense objects.
      */
-    public SortedSet<ILicense> getLicenses(final LicenseFilter filter) {
+    public UnmodifiableSortedSet<ILicense> getLicenses(final LicenseFilter filter) {
+        SortedSet<ILicense> result = new TreeSet<>();
         switch (filter) {
         case ALL:
-            return Collections.unmodifiableSortedSet(licenses);
+            result = licenses;
+            break;
         case APPROVED:
-            SortedSet<ILicense> result = new TreeSet<>();
+            result = new TreeSet<>();
             licenses.stream().filter(getApprovedLicensePredicate()).forEach(result::add);
-            return result;
+            break;
         case NONE:
         default:
-            return Collections.emptySortedSet();
+            result = Collections.emptySortedSet();
         }
+        return (UnmodifiableSortedSet<ILicense>) UnmodifiableSortedSet.unmodifiableSortedSet(result);
     }
 
     /**
diff --git a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
index b00aec082..ec6420aed 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
@@ -22,7 +22,11 @@
 import java.io.StringReader;
 
 import java.util.Collections;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
+import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.rat.Defaults;
 import org.apache.rat.api.Document;
 import org.apache.rat.configuration.builders.AnyBuilder;
@@ -38,12 +42,19 @@
 
 public class HeaderCheckWorkerTest {
 
+    /** Create an unmodifiable sorted set from members */
+    private UnmodifiableSortedSet<ILicense> asLicenses(ILicense... licenses) {
+        SortedSet<ILicense> inner = new  TreeSet<>();
+        inner.addAll(List.of(licenses));
+        return (UnmodifiableSortedSet<ILicense>) UnmodifiableSortedSet.unmodifiableSortedSet(inner);
+    }
+
     @Test
     public void emptyInputIsUnknownTest() throws RatHeaderAnalysisException {
         final Document subject = new TestingDocument("subject");
         subject.getMetaData().setApprovalPredicate(Defaults.builder().build().getLicenseSetFactory().getApprovedLicensePredicate());
         ILicense matcher = new TestingLicense("test", "test");
-        HeaderCheckWorker worker = new HeaderCheckWorker(new TestingMatcher(), new StringReader(""), Lists.list(matcher), subject);
+        HeaderCheckWorker worker = new HeaderCheckWorker(new TestingMatcher(), new StringReader(""), asLicenses(matcher), subject);
         worker.read();
         assertThat(subject.getMetaData().unapprovedLicenses().count()).isEqualTo(1);
         assertThat(subject.getMetaData().unapprovedLicenses().toList().get(0).getLicenseFamily()).isEqualTo(ILicenseFamily.UNKNOWN);
@@ -53,7 +64,7 @@ public void emptyInputIsUnknownTest() throws RatHeaderAnalysisException {
     public void generatedFileDetectionTest() throws Exception {
         final Document subject = new TestingDocument(new StringReader("Generated from configure.ac by autoheader"), "subject");
         IHeaderMatcher matcher = new AnyBuilder().setResource("/org/apache/rat/generation-keywords.txt").build();
-        HeaderCheckWorker worker = new HeaderCheckWorker(matcher, subject.reader(), Collections.emptyList(), subject);
+        HeaderCheckWorker worker = new HeaderCheckWorker(matcher, subject.reader(), asLicenses(), subject);
         worker.read();
         assertThat(subject.getMetaData().getDocumentType()).isEqualTo(Document.Type.IGNORED);
     }

From 462ed9bba102898b733effa1aa9f43b897cca797 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 14:14:04 +0100
Subject: [PATCH 14/36] Use MutableInt in ClaimValidator

---
 .../rat/config/results/ClaimValidator.java    | 41 +++++++++++--------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/results/ClaimValidator.java b/apache-rat-core/src/main/java/org/apache/rat/config/results/ClaimValidator.java
index f295f276b..b4f81da32 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/results/ClaimValidator.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/results/ClaimValidator.java
@@ -23,6 +23,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.mutable.MutableInt;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.utils.DefaultLog;
 
@@ -35,11 +36,11 @@ public final class ClaimValidator {
     /**
      * The map of  max counter limits.
      */
-    private final ConcurrentHashMap<ClaimStatistic.Counter, Integer> max = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<ClaimStatistic.Counter, MutableInt> max = new ConcurrentHashMap<>();
     /**
      * The map of  min counter limits.
      */
-    private final ConcurrentHashMap<ClaimStatistic.Counter, Integer> min = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<ClaimStatistic.Counter, MutableInt> min = new ConcurrentHashMap<>();
     /**
      * {@code true} if errors were detected in the claim.
      */
@@ -51,8 +52,8 @@ public final class ClaimValidator {
     public ClaimValidator() {
         for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
             max.put(counter,
-                    counter.getDefaultMaxValue() < 0 ? Integer.MAX_VALUE : counter.getDefaultMaxValue());
-            min.put(counter, counter.getDefaultMinValue());
+                    new MutableInt(counter.getDefaultMaxValue() < 0 ? Integer.MAX_VALUE : counter.getDefaultMaxValue()));
+            min.put(counter, new MutableInt(counter.getDefaultMinValue()));
         }
     }
 
@@ -70,22 +71,28 @@ public boolean hasErrors() {
      * @param value the value to set. A negative value specifies no maximum value.
      */
     public void setMax(final ClaimStatistic.Counter counter, final int value) {
-        if (value < 0) {
-            max.put(counter, Integer.MAX_VALUE);
-        } else {
-            max.put(counter, value);
-        }
-        min.compute(counter, (k, v) -> v != null && v > max.get(k) ? max.get(k) : v);
+        MutableInt maxValue = max.compute(counter, (k, v) -> {
+            v.setValue(value < 0 ? Integer.MAX_VALUE : value);
+            return v; });
+        min.compute(counter, (k, v) ->  {
+            if (v.intValue() > maxValue.intValue()) {
+                v.setValue(maxValue.intValue());
+            }
+            return v; });
     }
 
     /**
-     * Sets the max value for the specified counter.
+     * Sets the min value for the specified counter.
      * @param counter the counter to set the limit for.
      * @param value the value to set. A negative value specifies no maximum value.
      */
     public void setMin(final ClaimStatistic.Counter counter, final int value) {
-        min.put(counter, value);
-        max.compute(counter, (k, v) -> v == null || v < value ? value : v);
+        min.put(counter, new MutableInt(value));
+        max.compute(counter, (k, v) -> {
+            if (v.intValue() < value) {
+                v.setValue(value);
+            }
+            return v; });
     }
 
     /**
@@ -94,8 +101,7 @@ public void setMin(final ClaimStatistic.Counter counter, final int value) {
      * @return the limit for the counter or 0 if not set.
      */
     public int getMax(final ClaimStatistic.Counter counter) {
-        Integer result = max.get(counter);
-        return result == null ? 0 : result;
+        return max.get(counter).intValue();
     }
 
     /**
@@ -104,8 +110,7 @@ public int getMax(final ClaimStatistic.Counter counter) {
      * @return the limit for the counter or 0 if not set.
      */
     public int getMin(final ClaimStatistic.Counter counter) {
-        Integer result = min.get(counter);
-        return result == null ? 0 : result;
+        return min.get(counter).intValue();
     }
 
     /**
@@ -115,7 +120,7 @@ public int getMin(final ClaimStatistic.Counter counter) {
      * @return {@code true} if the count is within the limits, {@code false} otherwise.
      */
     public boolean isValid(final ClaimStatistic.Counter counter, final int count) {
-        boolean result = max.get(counter) >= count && min.get(counter) <= count;
+        boolean result = max.get(counter).intValue() >= count && min.get(counter).intValue() <= count;
         hasErrors |= !result;
         return result;
     }

From bc8cf429bd5681fcd06d325926470d66beaf78e2 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 14:26:31 +0100
Subject: [PATCH 15/36] fix case statement

---
 .../org/apache/rat/config/exclusion/ExclusionProcessor.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 8a32b56fb..1ddce2e8a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -216,7 +216,7 @@ public ExclusionProcessor addExcludedCollection(final StandardCollection collect
     public DocumentNameMatcher getNameMatcher(final DocumentName basedir) {
         // if lastMatcher is not set or the basedir is not the same as the last one then
         // we have to regenerate the matching document.
-        // Otherwise we can just return the lastMatcher since there is no change.
+        // Otherwise, we can just return the lastMatcher since there is no change.
         if (lastMatcher == null || !basedir.equals(lastMatcherBaseDir)) {
             lastMatcherBaseDir = basedir;
 
@@ -409,11 +409,13 @@ public void deserialize(final Node n) {
                         includedCollections.add(collection);
                         break;
                     case "includedPath":
-                        excludedPaths.add(new DocumentNameMatcher(attributes.get("name"),
+                        includedPaths.add(new DocumentNameMatcher(attributes.get("name"),
                                 (Predicate<DocumentName>) x -> {
                                     throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
                                 }));
                         break;
+                    default:
+                        throw new NotImplementedException("Deserialization for %s is not implemented", child.getNodeName());
                 }
 
             }

From 73cef380612a276750bacbd28c7f060ab252857d Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 14:28:20 +0100
Subject: [PATCH 16/36] fix spotbugs issues

---
 apache-rat-core/src/main/java/org/apache/rat/Reporter.java | 6 +++++-
 .../rat/analysis/license/SimplePatternBasedLicense.java    | 2 ++
 .../apache/rat/analysis/matchers/SimpleTextMatcher.java    | 7 +++++--
 .../java/org/apache/rat/config/parameters/Description.java | 2 +-
 .../apache/rat/configuration/XMLConfigurationReader.java   | 3 +++
 .../rat/configuration/builders/ChildContainerBuilder.java  | 2 +-
 .../rat/configuration/builders/MatcherRefBuilder.java      | 4 ++++
 .../src/main/java/org/apache/rat/header/HeaderMatcher.java | 2 ++
 .../src/main/java/org/apache/rat/help/Licenses.java        | 3 +++
 .../main/java/org/apache/rat/tools/xsd/XsdGenerator.java   | 3 +--
 apache-rat/pom.xml                                         | 7 +++++++
 apache-rat/spotbugs-ignore.xml                             | 4 ++++
 12 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index 34425bde1..b880066f3 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -52,6 +52,8 @@
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * Class that executes the report as defined in a {@link ReportConfiguration} and stores
  * the result for later handling.
@@ -195,6 +197,7 @@ public void format(final ReportConfiguration config) throws RatException {
          * @param output the output stream to write to.
          * @throws RatException on error.
          */
+        @SuppressFBWarnings({"MALICIOUS_XSLT", "XXE_DTD_TRANSFORM_FACTORY", " XXE_XSLT_TRANSFORM_FACTORY"})
         public void format(final IOSupplier<InputStream> stylesheet, final IOSupplier<OutputStream> output) throws RatException {
             TransformerFactory tf = TransformerFactory.newInstance();
             Transformer transformer;
@@ -227,6 +230,7 @@ public void writeSummary(final Appendable appendable) throws IOException {
             }
         }
 
+        @SuppressFBWarnings("EI_EXPOSE_REP2")
         public static final class Builder {
             /** The document that was generated */
             private Document document;
@@ -244,7 +248,7 @@ public Builder document(final Document document) {
                 this.document = document;
                 return this;
             }
-
+            @SuppressFBWarnings("XXE_DOCUMENT")
             public Builder document(final String fileName, final DocumentName workingDirectory) {
                 DocumentBuilder builder;
                 try {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/license/SimplePatternBasedLicense.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/license/SimplePatternBasedLicense.java
index 21a3230ea..4032d01fb 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/license/SimplePatternBasedLicense.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/license/SimplePatternBasedLicense.java
@@ -20,6 +20,7 @@
 
 import java.util.Arrays;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.apache.rat.DeprecationReporter;
 import org.apache.rat.configuration.builders.AbstractBuilder;
 import org.apache.rat.configuration.builders.AnyBuilder;
@@ -31,6 +32,7 @@
  * @since Rat 0.8
  * @deprecated Use new configuration options
  */
+@SuppressFBWarnings("EI_EXPOSE_REP2")
 @Deprecated // Since 0.16
 @DeprecationReporter.Info(since = "0.16", forRemoval = true, use = "new configuration options")
 public class SimplePatternBasedLicense  extends BaseLicense {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/matchers/SimpleTextMatcher.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/matchers/SimpleTextMatcher.java
index c77ddf096..2a5d46b51 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/matchers/SimpleTextMatcher.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/matchers/SimpleTextMatcher.java
@@ -23,6 +23,8 @@
 import org.apache.rat.config.parameters.ComponentType;
 import org.apache.rat.config.parameters.ConfigComponent;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * A simple text matching IHeaderMatcher implementation.
  */
@@ -44,11 +46,12 @@ public SimpleTextMatcher(final String simpleText) {
         this(null, simpleText);
     }
 
+    // no sonar and supress FI_USELESS because this is how we ensure that the finalize bug does not bite us
+    @SuppressFBWarnings("FI_USELESS")
     @Override
     protected final void finalize() throws Throwable { // NOSONAR
-        // no sonar because this is how we ensure that the finalize bug does not bite us
+        // finalizer attack remediation.
         super.finalize(); // NOSONAR
-      // finalizer attack remediation.
     }
 
     /**
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/parameters/Description.java b/apache-rat-core/src/main/java/org/apache/rat/config/parameters/Description.java
index 6aa20bd38..a4e579dab 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/parameters/Description.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/parameters/Description.java
@@ -37,7 +37,7 @@
 /**
  * A description of a component.
  */
-public class Description {
+public final class Description {
     /** The type of component this describes */
     private final ComponentType type;
     /**
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
index 04b9fbe45..deb63c17e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/XMLConfigurationReader.java
@@ -61,6 +61,8 @@
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * A class that reads the XML configuration file format.
  */
@@ -606,6 +608,7 @@ public void readMatcherBuilders() {
         nodeListConsumer(document.getElementsByTagName(XMLConfig.MATCHER), this::parseMatcherBuilder);
     }
 
+    @SuppressFBWarnings("URLCONNECTION_SSRF_FD")
     @Override
     public void addMatchers(final URI uri) {
         read(uri);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
index d40a657d2..172314fbe 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/ChildContainerBuilder.java
@@ -59,7 +59,7 @@ protected ChildContainerBuilder() {
      */
     public AbstractBuilder setResource(final String resourceName) {
         // this method is called by reflection
-        URL url = this.getClass().getResource(resourceName);
+        URL url = AbstractBuilder.class.getResource(resourceName);
         if (url == null) {
             throw new ConfigurationException("Unable to read matching text file: " + resourceName);
         }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
index 68598d4c7..1662220f3 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/configuration/builders/MatcherRefBuilder.java
@@ -27,6 +27,8 @@
 import org.apache.rat.config.parameters.ConfigComponent;
 import org.apache.rat.config.parameters.MatcherBuilder;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * A reference matching Matcher builder.
  * <p>
@@ -62,6 +64,7 @@ public MatcherRefBuilder setRefId(final String refId) {
      * @param matchers the Map of ids to instances.
      * @return this builder for chaining.
      */
+    @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Expected external update of matchers.")
     public MatcherRefBuilder setMatcherMap(final Map<String, IHeaderMatcher> matchers) {
         // this method is called by reflection
         this.matchers = matchers;
@@ -109,6 +112,7 @@ public static class IHeaderMatcherProxy implements IHeaderMatcher {
          * @param proxyId the id of the matcher to find.
          * @param matchers a mapping of matchers that have been found.
          */
+        @SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "Expected external update of matchers.")
         public IHeaderMatcherProxy(final String proxyId, final Map<String, IHeaderMatcher> matchers) {
             this.proxyId = proxyId;
             this.matchers = matchers;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java b/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
index 89b71b0a2..7f05afa3a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/header/HeaderMatcher.java
@@ -18,6 +18,7 @@
  */ 
 package org.apache.rat.header;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.apache.rat.DeprecationReporter;
 
 import java.io.IOException;
@@ -35,6 +36,7 @@
  * <p><strong>Note:</strong> use only from a single thread.</p>
  *
  */
+@SuppressFBWarnings("EI_EXPOSE_REP2")
 @Deprecated // since 0.17
 @DeprecationReporter.Info(since = "0.17", forRemoval = true)
 public class HeaderMatcher {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java b/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
index 0277186b0..bac55af54 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/help/Licenses.java
@@ -43,6 +43,8 @@
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 import static java.lang.String.format;
 
 /**
@@ -64,6 +66,7 @@ public final class Licenses extends AbstractHelp {
      * @param config The configuration that contains the license information.
      * @param writer the writer to write the report to.
      */
+    @SuppressFBWarnings("EI_EXPOSE_REP2")
     public Licenses(final ReportConfiguration config, final Writer writer) {
         this.config = config;
         this.licenses = config.getLicenses(LicenseFilter.ALL);
diff --git a/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java b/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
index 68437fed6..5f466cb06 100644
--- a/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
+++ b/apache-rat-tools/src/main/java/org/apache/rat/tools/xsd/XsdGenerator.java
@@ -179,11 +179,10 @@ private void writeMatchers() throws IOException {
     }
 
     private void writeMatcherElements() throws IOException {
-        MatcherBuilderTracker tracker = MatcherBuilderTracker.instance();
         writer.open(Type.ELEMENT, "name", XMLConfig.MATCHER, "abstract", "true").close(Type.ELEMENT);
 
         // matchers
-        for (Class<?> clazz : tracker.getClasses()) {
+        for (Class<?> clazz : MatcherBuilderTracker.instance().getClasses()) {
             Description desc = DescriptionBuilder.buildMap(clazz);
             if (desc != null) {
                 boolean hasResourceAttr = false;
diff --git a/apache-rat/pom.xml b/apache-rat/pom.xml
index f915d7b05..8b4ea0f61 100644
--- a/apache-rat/pom.xml
+++ b/apache-rat/pom.xml
@@ -48,6 +48,13 @@
   </dependencies>
   <build>
     <plugins>
+      <plugin>
+        <groupId>com.github.spotbugs</groupId>
+        <artifactId>spotbugs-maven-plugin</artifactId>
+        <configuration>
+          <excludeFilterFile>spotbugs-ignore.xml</excludeFilterFile>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-source-plugin</artifactId>
diff --git a/apache-rat/spotbugs-ignore.xml b/apache-rat/spotbugs-ignore.xml
index 085293a2b..b0a2af2a3 100644
--- a/apache-rat/spotbugs-ignore.xml
+++ b/apache-rat/spotbugs-ignore.xml
@@ -24,6 +24,10 @@
     <Bug pattern='EI_EXPOSE_REP'/>
   </Match>
 
+  <Match>
+    <Bug pattern='EI_EXPOSE_REP2'/>
+  </Match>q
+
   <Match>
     <Class name="org.apache.rat.configuration.XMLConfigurationReader"/>
     <Bug pattern='XXE_DOCUMENT'/>

From 2c7319407164c7896c3ab7b5096c2dc79846c4cd Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 14:39:27 +0100
Subject: [PATCH 17/36] fix spotbugs issues

---
 .../main/java/org/apache/rat/analysis/HeaderCheckWorker.java    | 2 --
 .../src/main/java/org/apache/rat/anttasks/Report.java           | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java b/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
index d4ae8d888..122a5f512 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/analysis/HeaderCheckWorker.java
@@ -21,8 +21,6 @@
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.Reader;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Locale;
 import java.util.Objects;
 
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
index 80ac5dcef..1eb92b4cb 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
@@ -474,7 +474,7 @@ protected ReportConfiguration validate(final ReportConfiguration cfg) {
      * @deprecated use &lt;editCopyright&gt; amd &lt;editOverwrite&gt; instead.
      */
     @Deprecated
-    public static class AddLicenseHeaders extends EnumeratedAttribute {
+    public final static class AddLicenseHeaders extends EnumeratedAttribute {
         /**
          * add license headers and create *.new file
          */

From 86eac78af5f478a6c0b211914e0e349ab8a1b41c Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 14:52:38 +0100
Subject: [PATCH 18/36] fix spotbugs issues

---
 .../src/main/java/org/apache/rat/anttasks/Report.java           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
index 1eb92b4cb..efb28ab30 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
@@ -474,7 +474,7 @@ protected ReportConfiguration validate(final ReportConfiguration cfg) {
      * @deprecated use &lt;editCopyright&gt; amd &lt;editOverwrite&gt; instead.
      */
     @Deprecated
-    public final static class AddLicenseHeaders extends EnumeratedAttribute {
+    public static final class AddLicenseHeaders extends EnumeratedAttribute {
         /**
          * add license headers and create *.new file
          */

From e886cf8c3f1ac3a2c313218cfca9db566acd1d47 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 1 Jun 2026 16:26:27 +0100
Subject: [PATCH 19/36] created TempDir replacement to support Windows

---
 .../java/org/apache/rat/ReporterTest.java     | 100 ++++++++++++++----
 1 file changed, 77 insertions(+), 23 deletions(-)

diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 207bd91c5..9133a982d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -26,16 +26,20 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintStream;
+import java.lang.reflect.Method;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
 
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.TreeMap;
+import java.util.UUID;
 import java.util.stream.Stream;
 import javax.xml.XMLConstants;
 import javax.xml.transform.Source;
@@ -67,8 +71,12 @@
 import org.apache.rat.testhelpers.data.TestData;
 import org.apache.rat.testhelpers.data.ValidatorData;
 import org.apache.rat.walker.DirectoryWalker;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.api.TestInfo;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -80,9 +88,26 @@
  * Tests the output of the Reporter.
  */
 public class ReporterTest {
-    @TempDir
-    File tempDirectory;
+    /**
+     * temporary file.  Not using tempDir because it does not
+     * always work.
+     */
+    private static Path tempPath;
+    /**
+     * The TestInfo for the current test.
+     */
+    private TestInfo testInfo;
+
+    /**
+     * The directory for the test.
+     */
+    private Path testPath;
+
+    /**
+     * Directory for the test data.
+     */
     final String basedir;
+
     private final OptionCollectionParser collectionParser;
 
     ReporterTest() throws URISyntaxException {
@@ -90,9 +115,38 @@ public class ReporterTest {
         collectionParser = new OptionCollectionParser(BaseOptionCollection.builder().build());
     }
 
+    @BeforeAll
+    static void setUp() throws IOException {
+        tempPath = Files.createTempDirectory("ReporterTest");
+    }
+
+    @AfterAll
+    static void cleanup() throws IOException {
+        FileUtils.deleteDirectory(tempPath.toFile());
+    }
+
+    @BeforeEach
+    void setUpTest(TestInfo testInfo) {
+        this.testInfo = testInfo;
+        Optional<Method> testMethod = testInfo.getTestMethod();
+        this.testPath = tempPath.resolve(testMethod.isPresent() ?
+                        testMethod.get().getName() :
+                        UUID.randomUUID().toString());
+        File file = testPath.toFile();
+        if (!file.exists()) {
+            if (!file.mkdirs()) {
+                throw new RuntimeException("Unable to create temp directory: " + file.getName());
+            }
+        } else {
+            if (!file.isDirectory()) {
+                throw new RuntimeException(file.getName() + " is NOT a directory.");
+            }
+        }
+    }
+
     @Test
-    public void testExecute() throws RatException, ParseException, IOException {
-        File output = new File(tempDirectory, "testExecute");
+    void testExecute() throws RatException, ParseException, IOException {
+        File output = testPath.resolve("output.xml").toFile();
         BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
         ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
         ClaimStatistic statistic = new Reporter(ctxt.getConfiguration()).execute().getStatistic();
@@ -144,8 +198,8 @@ public void testExecute() throws RatException, ParseException, IOException {
     }
 
     @Test
-    public void testOutputOption() throws Exception {
-        File output = new File(tempDirectory, "test");
+    void testOutputOption() throws Exception {
+        File output = testPath.resolve("output.txt").toFile();
         ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-file", output.getCanonicalPath(), basedir});
         new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
         assertThat(output.exists()).isTrue();
@@ -156,8 +210,8 @@ public void testOutputOption() throws Exception {
     }
 
     @Test
-    public void testDefaultOutput() throws Exception {
-        File output = new File(tempDirectory, "testDefaultOutput");
+    void testDefaultOutput() throws Exception {
+        File output = testPath.resolve("captured.txt").toFile();
         BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
 
         PrintStream origin = System.out;
@@ -182,7 +236,7 @@ private static Map<String, String> mapOf(String... parts) {
     }
 
     @Test
-    public void testXMLOutput() throws Exception {
+    void testXMLOutput() throws Exception {
         Map<String, Map<String, String>> expected = new HashMap<>();
         expected.put("/.hiddenDirectory", mapOf("isDirectory", "true", "mediaType", "application/octet-stream",
                 "type", "IGNORED"));
@@ -212,9 +266,9 @@ public void testXMLOutput() throws Exception {
         expected.put("/tri.txt", mapOf("encoding", "ISO-8859-1", "mediaType", "text/plain",
                 "type", "STANDARD"));
 
-        File output = new File(tempDirectory, ".rat/testXMLOutput");
+        File output = testPath.resolve(".rat/testXMLOutput").toFile();
         output.getParentFile().mkdir();
-        ArgumentContext ctxt = collectionParser.parseCommands(tempDirectory, new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
+        ArgumentContext ctxt = collectionParser.parseCommands(testPath.toFile(), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
         new Reporter(ctxt.getConfiguration()).execute().format(ctxt.getConfiguration());
 
         assertThat(output).exists();
@@ -404,7 +458,7 @@ private Validator initValidator() throws SAXException {
     }
 
     @Test
-    public void xmlReportTest() throws Exception {
+    void xmlReportTest() throws Exception {
         ReportConfiguration configuration = initializeConfiguration();
         Document doc = new Reporter(configuration).execute().getDocument();
 
@@ -443,7 +497,7 @@ public void xmlReportTest() throws Exception {
     }
 
     @Test
-    public void plainReportTest() throws Exception {
+    void plainReportTest() throws Exception {
         final String NL = System.lineSeparator();
         final String SEPARATOR = "*****************************************************";
         final String HEADER = SEPARATOR + NL + //
@@ -464,7 +518,7 @@ public void plainReportTest() throws Exception {
     }
 
     @Test
-    public void unapprovedLicensesReportTest() throws Exception {
+    void unapprovedLicensesReportTest() throws Exception {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         ReportConfiguration configuration = initializeConfiguration();
         configuration.setOut(new ReportConfiguration.IODescriptor<>("unapprovedLicensesReportTest", () -> out));
@@ -518,22 +572,22 @@ static Stream<Arguments> getTestData() {
     @ParameterizedTest( name = "{index} {0}")
     @MethodSource("getTestData")
     void testReportData(String name, TestData test) throws Exception {
-        Path tempPath = tempDirectory.toPath();
-        Path basePath = tempPath.resolve(test.getTestName());
-        org.apache.rat.utils.FileUtils.mkDir(basePath.toFile());
-        test.setupFiles(basePath);
-        ArgumentContext ctxt = collectionParser.parseCommands(basePath.toFile(),
-                test.getCommandLine(basePath.toString()));
+        Path invokePath = testPath.resolve(test.getTestName());
+        org.apache.rat.utils.FileUtils.mkDir(invokePath.toFile());
+
+        test.setupFiles(invokePath);
+        ArgumentContext ctxt = collectionParser.parseCommands(invokePath.toFile(),
+                test.getCommandLine(invokePath.toString()));
         if (test.expectingException()) {
             assertThatThrownBy(() -> new Reporter(ctxt.getConfiguration()).execute()).as("Expected throws from " + name)
                     .hasMessageContaining(test.getExpectedException().getMessage());
             ValidatorData data = new ValidatorData(Reporter.Output.builder().configuration(ctxt.getConfiguration()).build(),
-                    basePath.toString());
+                    invokePath.toString());
             test.getValidator().accept(data);
         } else {
             Reporter.Output output = ctxt.getConfiguration() != null ? new Reporter(ctxt.getConfiguration()).execute() :
                     Reporter.Output.builder().build();
-            ValidatorData data = new ValidatorData(output, basePath.toString());
+            ValidatorData data = new ValidatorData(output, invokePath.toString());
             data.getOutput().format(data.getConfiguration());
             test.getValidator().accept(data);
         }

From f576ae2459c23203c78f89aecc36569b5b717870 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Fri, 5 Jun 2026 16:48:37 +0100
Subject: [PATCH 20/36] Fixed issues with DocumentName and DocumentNameBuilder.

Reworked tests for more complete coverage.
Fixed issue with ReportTestDataProvider.java
---
 .../java/org/apache/rat/document/DocumentName.java     | 10 ++++++++++
 .../rat/testhelpers/data/ReportTestDataProvider.java   |  7 ++++---
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index c86106920..3bf2f2c60 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -672,6 +672,16 @@ private int compareData(final DocumentName.FSInfoData otherData) {
             return result;
         }
 
+        /**
+         * Creates a path separated by the directory separator.
+         * Starting with an empty string will cause the directory separateor to appear at the beginning.
+         * @param segments the segments that make up the path.
+         * @return the path string.
+         */
+        public String mkPath(final String... segments) {
+            return String.join(dirSeparator(), segments);
+        }
+
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
index 4b50a8d9d..62a0ab968 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
@@ -26,6 +26,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
@@ -907,11 +908,11 @@ protected void editLicenseTest(final Set<TestData> result, final Option option)
                     try {
                         assertThat(validatorData.getStatistic()).isNotNull();
                         File javaFile = validatorData.getBaseDir().resolve("NoLicense.java").toFile();
-                        String contents = String.join("\n", IOUtils.readLines(new FileReader(javaFile)));
+                        String contents = String.join("\n", IOUtils.readLines(new FileReader(javaFile, StandardCharsets.UTF_8)));
                         assertThat(contents).isEqualTo("class NoLicense {}");
                         File resultFile = validatorData.getBaseDir().resolve("NoLicense.java.new").toFile();
                         assertThat(resultFile).exists();
-                        contents = String.join("\n", IOUtils.readLines(new FileReader(resultFile)));
+                        contents = String.join("\n", IOUtils.readLines(new FileReader(resultFile, StandardCharsets.UTF_8)));
                         assertThat(contents).isEqualTo("""
                                 /*
                                  * Licensed to the Apache Software Foundation (ASF) under one
@@ -1247,7 +1248,7 @@ protected void outputStyleTest(final Set<TestData> result, final Option option)
                         DefaultLog.getInstance().warn("outputStyleTest setup for " + basePath);
                         DocumentName name = DocumentName.builder().setName("fileStyleSheet.xslt")
                                 .setBaseName(basePath.toString()).build();
-                        try (FileWriter fileWriter = new FileWriter(new File(name.getBaseName(), name.getName()));
+                        try (FileWriter fileWriter = new FileWriter(name.asFile(), StandardCharsets.UTF_8);
                              XmlWriter writer = new XmlWriter(fileWriter)) {
                             writer.startDocument()
                                     .comment(DataUtils.ASF_TEXT)

From ac06009e5eba22097a0d51d4f16a4ab69040050f Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Tue, 9 Jun 2026 13:36:01 +0100
Subject: [PATCH 21/36] fixes for DocumentName errors

---
 .../java/org/apache/rat/commandline/Arg.java  | 12 ++--
 .../apache/rat/ReporterOptionsProvider.java   | 66 ++++++++++++-------
 .../rat/commandline/ConvertersTest.java       | 35 ++++++++++
 3 files changed, 83 insertions(+), 30 deletions(-)
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java

diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
index 922aea630..3ba9c7005 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
@@ -218,7 +218,7 @@ public enum Arg {
      * Option to read a file licenses to be removed from the approved list.
      */
     LICENSES_DENIED_FILE(new OptionGroup().addOption(Option.builder().longOpt("licenses-denied-file")
-            .hasArg().argName("File").type(File.class)
+            .hasArg().argName("File").type(DocumentName.class)
             .converter(Converters.FILE_CONVERTER)
             .desc("Name of file containing comma separated lists of the denied license IDs. " +
                     "These licenses will be removed from the list of approved licenses. " +
@@ -326,14 +326,14 @@ public enum Arg {
      */
     EXCLUDE_FILE(new OptionGroup()
             .addOption(Option.builder("E").longOpt("exclude-file")
-                    .argName("File").hasArg().type(File.class)
+                    .argName("File").hasArg().type(DocumentName.class)
                     .converter(Converters.FILE_CONVERTER)
                     .deprecated(DeprecatedAttributes.builder().setForRemoval(true).setSince("0.17")
                             .setDescription(StdMsgs.useMsg("--input-exclude-file")).get())
                     .desc("Reads <Expression> entries from a file. Entries will be excluded from processing.")
                     .build())
             .addOption(Option.builder().longOpt("input-exclude-file")
-                    .argName("File").hasArg().type(File.class)
+                    .argName("File").hasArg().type(DocumentName.class)
                     .converter(Converters.FILE_CONVERTER)
                     .desc("Reads <Expression> entries from a file. Entries will be excluded from processing.")
                     .build()),
@@ -408,12 +408,12 @@ public enum Arg {
      */
     INCLUDE_FILE(new OptionGroup()
             .addOption(Option.builder().longOpt("input-include-file")
-                    .argName("File").hasArg().type(File.class)
+                    .argName("File").hasArg().type(DocumentName.class)
                     .converter(Converters.FILE_CONVERTER)
                     .desc("Reads <Expression> entries from a file. Entries will override excluded files.")
                     .build())
             .addOption(Option.builder().longOpt("includes-file")
-                    .argName("File").hasArg().type(File.class)
+                    .argName("File").hasArg().type(DocumentName.class)
                     .converter(Converters.FILE_CONVERTER)
                     .desc("Reads <Expression> entries from a file. Entries will override excluded files.")
                     .deprecated(DeprecatedAttributes.builder().setForRemoval(true).setSince("0.17")
@@ -485,7 +485,7 @@ public enum Arg {
      * Stop processing an input stream and declare an input file.
      */
     DIR(new OptionGroup().addOption(Option.builder().option("d").longOpt("dir").hasArg()
-            .type(File.class)
+            .type(DocumentName.class)
             .desc("Used to indicate end of list when using options that take multiple arguments.").argName("DirOrArchive")
             .deprecated(DeprecatedAttributes.builder().setForRemoval(true).setSince("0.17")
                     .setDescription("Use the standard '--' to signal the end of arguments.").get()).build()),
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 580543729..c81581fc1 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -22,10 +22,13 @@
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileReader;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
+import java.io.Reader;
+import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.Arrays;
@@ -114,18 +117,26 @@ protected final ReportConfiguration generateConfig(List<Pair<Option, String[]>>
         return config;
     }
 
-    private File configureRatDir(Option option) {
-        configureSourceDir(option);
-        File result = new File(sourceDir, ".rat");
-        FileUtils.mkDir(result);
-        return result;
-    }
-
+    /**
+     * Creates the srcDir.,.
+     * @param option the name for the srcDir.
+     */
     private void configureSourceDir(Option option) {
         sourceDir = new File(baseDir, OptionFormatter.getName(option));
         FileUtils.mkDir(sourceDir);
     }
 
+    /**
+     * Creates the option/.rat directory
+     * @param option the name for the sourceDirectory.
+     */
+    private File configureRatDir(Option option) {
+        configureSourceDir(option);
+        File ratDir = new File(sourceDir, ".rat");
+        FileUtils.mkDir(ratDir);
+        return ratDir;
+    }
+
     private void validateNoArgSetup() throws IOException, RatException {
         // verify that without args the report is ok.
         TestingLog log = new TestingLog();
@@ -228,8 +239,7 @@ protected void licensesDeniedTest() {
     @OptionCollectionTest.TestFunction
     protected void licensesDeniedFileTest() {
         Option option = Arg.LICENSES_DENIED_FILE.find("licenses-denied-file");
-        File ratDir = configureRatDir(option);
-        File outputFile = FileUtils.writeFile(ratDir, "licensesDenied.txt", Collections.singletonList("ILLUMOS"));
+        File outputFile = FileUtils.writeFile(configureRatDir(option), "licensesDenied.txt", Collections.singletonList("ILLUMOS"));
         execLicensesDeniedTest(option, new String[]{outputFile.getAbsolutePath()});
     }
 
@@ -312,8 +322,13 @@ protected void counterMinTest() {
         });
     }
 
-    // exclude tests
-    private void execExcludeTest(final Option option, final String[] args, final boolean addIgnored) {
+    /**
+     * Runs the exclude tests.
+     * @param option The exclude option to run.
+     * @param args the arguments for the command line.
+     * @param includesRatDir @{code true} if the .rat directory was created.
+     */
+    private void execExcludeTest(final Option option, final String[] args, final boolean includesRatDir) {
         String[] notExcluded = {"notbaz", "well._afile"};
         String[] excluded = {"some.foo", "B.bar", "justbaz"};
 
@@ -329,20 +344,19 @@ private void execExcludeTest(final Option option, final String[] args, final boo
             Reporter reporter = new Reporter(config);
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(5);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 1 : 0);
 
             // filter out source
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
             output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 4 : 3);
         });
     }
 
     private void excludeFileTest(final Option option) {
-        File ratDir = configureRatDir(option);
-        File outputFile = FileUtils.writeFile(ratDir, "exclude.txt", Arrays.asList(EXCLUDE_ARGS));
+        File outputFile = FileUtils.writeFile(configureRatDir(option), "exclude.txt", Arrays.asList(EXCLUDE_ARGS));
         execExcludeTest(option, new String[]{outputFile.getAbsolutePath()}, true);
     }
 
@@ -482,8 +496,13 @@ protected void inputExcludeParsedScmTest() {
         });
     }
 
-    // include tests
-    private void execIncludeTest(final Option option, final String[] args, boolean addIgnored) {
+    /**
+     * Runs the include tests.
+     * @param option The include option to run.
+     * @param args the arguments for the command line.
+     * @param includesRatDir @{code true} if the .rat directory was created.
+     */
+    private void execIncludeTest(final Option option, final String[] args, final boolean includesRatDir) {
         Option excludeOption = Arg.EXCLUDE.option();
         String[] notExcluded = {"B.bar", "justbaz", "notbaz"};
         String[] excluded = {"some.foo"};
@@ -499,7 +518,8 @@ private void execIncludeTest(final Option option, final String[] args, boolean a
             Reporter reporter = new Reporter(config);
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(4);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 1 : 0);
+
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 1 : 0);
 
             // verify exclude removes most files.
             config = generateConfig(ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
@@ -507,7 +527,7 @@ private void execIncludeTest(final Option option, final String[] args, boolean a
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 4 : 3);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 4 : 3);
 
             // verify include pust them back
             config = generateConfig(ImmutablePair.of(option, args), ImmutablePair.of(excludeOption, EXCLUDE_ARGS));
@@ -515,13 +535,12 @@ private void execIncludeTest(final Option option, final String[] args, boolean a
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(addIgnored ? 2 : 1);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(includesRatDir ? 2 : 1 );
         });
     }
 
     private void includeFileTest(final Option option) {
-        File ratDir = configureRatDir(option);
-        File outputFile = FileUtils.writeFile(ratDir, "include.txt", Arrays.asList(INCLUDE_ARGS));
+        File outputFile = FileUtils.writeFile(configureRatDir(option), "include.txt", Arrays.asList(INCLUDE_ARGS));
         execIncludeTest(option, new String[]{outputFile.getAbsolutePath()}, true);
     }
 
@@ -766,8 +785,7 @@ protected void execLicensesApprovedTest(final Option option, String[] args) {
     @OptionCollectionTest.TestFunction
     protected void licensesApprovedFileTest() {
         Option option = Arg.LICENSES_APPROVED_FILE.find("licenses-approved-file");
-        File ratDir = configureRatDir(option);
-                File outputFile = FileUtils.writeFile(ratDir, "licensesApproved.txt", Collections.singletonList("GPL1"));
+        File outputFile = FileUtils.writeFile(configureRatDir(option), "licensesApproved.txt", Collections.singletonList("GPL1"));
         execLicensesApprovedTest(option, new String[]{outputFile.getAbsolutePath()});
     }
 
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java
new file mode 100644
index 000000000..20d05a22b
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java
@@ -0,0 +1,35 @@
+package org.apache.rat.commandline;
+
+import org.apache.rat.document.DocumentName;
+import org.apache.rat.document.FSInfoTest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.FieldSource;
+
+import java.io.File;
+import java.util.List;
+
+import static org.apache.rat.document.FSInfoTest.WINDOWS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ConvertersTest {
+
+    private static final DocumentName.FSInfo[] TEST_SUITE = FSInfoTest.TEST_SUITE;
+
+    @ParameterizedTest
+    @FieldSource("TEST_SUITE")
+    void convertFileNameTest(DocumentName.FSInfo fsInfo) {
+        String root = fsInfo.equals(WINDOWS) ? "D:\\" : fsInfo.roots()[0];
+        DocumentName workingDirectory = DocumentName.builder(fsInfo).setName("foo").setRoot(root).setBaseName("").build();
+        Converters.FILE_CONVERTER.setWorkingDirectory(workingDirectory);
+
+        for (String fn : List.of("rat.txt", "./rat.txt", "/rat.txt")) {
+            assertThat(Converters.FILE_CONVERTER.apply(fn).getName()).as(fn).isEqualTo(workingDirectory.getRoot() + fsInfo.mkPath("foo", "rat.txt"));
+        }
+
+        for (String fn : List.of("target/rat.txt", "./target/rat.txt", "/target/rat.txt")) {
+            assertThat(Converters.FILE_CONVERTER.apply(fn).getName()).as(fn).isEqualTo(workingDirectory.getRoot() + fsInfo.mkPath("foo", "target", "rat.txt"));
+        }
+    }
+
+}

From a8478ad2f400ff32b6f070d575886b217588dd0f Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Mon, 22 Jun 2026 15:32:22 +0100
Subject: [PATCH 22/36] fixed rebasing issues

---
 .../java/org/apache/rat/OptionCollection.java |  4 +-
 .../main/java/org/apache/rat/Reporter.java    |  1 -
 .../java/org/apache/rat/commandline/Arg.java  |  1 +
 .../org/apache/rat/document/DocumentName.java | 57 -------------------
 .../org/apache/rat/OptionCollectionTest.java  |  2 +
 .../java/org/apache/rat/ReporterTest.java     |  4 +-
 .../org/apache/rat/commandline/ArgTests.java  |  2 +-
 .../rat/commandline/ConvertersTest.java       | 35 ------------
 .../AbstractConfigurationOptionsProvider.java |  6 +-
 9 files changed, 11 insertions(+), 101 deletions(-)
 delete mode 100644 apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java

diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
index 65706862e..9130d6258 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
@@ -177,8 +177,8 @@ public static ReportConfiguration createConfiguration(final ArgumentContext argu
         Optional<Option> dirOpt = CLIOptionCollection.INSTANCE.getSelected(Arg.DIR);
         if (dirOpt.isPresent()) {
             try {
-                configuration.addSource(getReportable(commandLine.getParsedOptionValue(
-                        dirOpt.get()), configuration));
+                DocumentName directoryName = commandLine.getParsedOptionValue(dirOpt.get());
+                configuration.addSource(getReportable(directoryName.asFile(), configuration));
             } catch (ParseException e) {
                 throw new ConfigurationException("Unable to set parse " + dirOpt.get(), e);
             }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index b880066f3..c42ebac0e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -131,7 +131,6 @@ public static void listLicenses(final ReportConfiguration configuration, final L
                             lic.getLicenseFamily().getFamilyName(), lic.getNote()));
             pw.println();
         }
-        return statistic;
     }
 
     /**
diff --git a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
index 3ba9c7005..dc9911cf0 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/commandline/Arg.java
@@ -486,6 +486,7 @@ public enum Arg {
      */
     DIR(new OptionGroup().addOption(Option.builder().option("d").longOpt("dir").hasArg()
             .type(DocumentName.class)
+            .converter(Converters.FILE_CONVERTER)
             .desc("Used to indicate end of list when using options that take multiple arguments.").argName("DirOrArchive")
             .deprecated(DeprecatedAttributes.builder().setForRemoval(true).setSince("0.17")
                     .setDescription("Use the standard '--' to signal the end of arguments.").get()).build()),
diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index 3bf2f2c60..c6cc55f22 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -625,63 +625,6 @@ private int compareData(final DocumentName.FSInfoData otherData) {
             return result;
         }
 
-        /**
-         * Creates a path separated by the directory separator.
-         * Starting with an empty string will cause the directory separateor to appear at the beginning.
-         * @param segments the segments that make up the path.
-         * @return the path string.
-         */
-        public String mkPath(final String... segments) {
-            return String.join(dirSeparator(), segments);
-        }
-
-        /**
-         * Determines if the candidate string starts with a root or directory separator as defined in this
-         * FSInfo.
-         * @param candidate the candidate string to test.
-         * @return {@code true} if the candidate starts with a root or a directory separator.
-         */
-        public boolean startsWithRootOrSeparator(final String candidate) {
-            if (candidate == null) {
-                return false;
-            }
-            String target = candidate.trim();
-            if (StringUtils.isBlank(target)) {
-                return false;
-            }
-            for (String root : roots()) {
-                if (target.startsWith(root)) {
-                    return true;
-                }
-            }
-            return target.startsWith(dirSeparator());
-        }
-
-        private int compareData(final DocumentName.FSInfoData otherData) {
-            int result = Boolean.compare(this.data.isCaseSensitive, otherData.isCaseSensitive);
-            if (result == 0) {
-                result = this.data.separator.compareTo(otherData.separator);
-                if (result == 0) {
-                    if (new HashSet<>(this.data.roots).containsAll(otherData.roots)) {
-                        result = new HashSet<>(otherData.roots).containsAll(this.data.roots) ? 0 : 1;
-                    } else {
-                        result = -1;
-                    }
-                }
-            }
-            return result;
-        }
-
-        /**
-         * Creates a path separated by the directory separator.
-         * Starting with an empty string will cause the directory separateor to appear at the beginning.
-         * @param segments the segments that make up the path.
-         * @return the path string.
-         */
-        public String mkPath(final String... segments) {
-            return String.join(dirSeparator(), segments);
-        }
-
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
index 9832095f5..72871edf6 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
@@ -44,6 +44,7 @@
 import org.apache.rat.testhelpers.TestingLog;
 import org.apache.rat.utils.CasedString;
 import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.FileUtils;
 import org.apache.rat.utils.Log;
 import org.apache.rat.walker.ArchiveWalker;
 import org.apache.rat.walker.DirectoryWalker;
@@ -181,6 +182,7 @@ public static Map<String, OptionTest> processTestFunctionAnnotations(Object test
     public void testDeprecatedUseLogged() throws IOException {
         TestingLog log = new TestingLog();
         try {
+            FileUtils.mkDir(testPath.resolve("target").toFile());
             DefaultLog.setInstance(log);
             String[] args = {"--dir", "target", "-a"};
             ReportConfiguration config = OptionCollection.parseCommands(testPath.toFile(), args, o -> fail("Help printed"), true);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 9133a982d..9aab15aad 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -58,6 +58,7 @@
 import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.Arg;
 import org.apache.rat.commandline.ArgumentContext;
+import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.document.FileDocument;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.license.ILicenseFamily;
@@ -536,13 +537,12 @@ void unapprovedLicensesReportTest() throws Exception {
     void listLicensesReportTest() throws Exception {
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         ReportConfiguration configuration = initializeConfiguration();
-        configuration.setOut(() -> out);
+        configuration.setOut(new ReportConfiguration.IODescriptor<>("listLicensesReportTest", () -> out));
         configuration.setStyleSheet(StyleSheets.UNAPPROVED_LICENSES.getStyleSheet());
         Reporter.listLicenses(configuration, LicenseSetFactory.LicenseFilter.NONE);
 
         out.flush();
         String document = out.toString();
-
         assertThat(document).contains("Licenses (NONE):");
     }
 
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
index 742632c5a..9ed0df624 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
@@ -64,7 +64,7 @@ public void setOut(File file) {
 
         CommandLine commandLine = createCommandLine(new String[]{"--output-file", fileName});
         OutputFileConfig configuration = new OutputFileConfig();
-        ArgumentContext ctxt = new ArgumentContext(localFile, configuration, commandLine);
+        ArgumentContext ctxt = new ArgumentContext(localFile, configuration, CLIOptionCollection.INSTANCE.getOptions(), new String[]{"--output-file", fileName});
         Arg.processArgs(ctxt, CLIOptionCollection.INSTANCE);
         if (name.equals("/rat.txt")) {
             assertThat(fsInfo.normalize(configuration.actual.getAbsolutePath())).isEqualTo(localFileName.getRoot() + "rat.txt");
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java
deleted file mode 100644
index 20d05a22b..000000000
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ConvertersTest.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package org.apache.rat.commandline;
-
-import org.apache.rat.document.DocumentName;
-import org.apache.rat.document.FSInfoTest;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.FieldSource;
-
-import java.io.File;
-import java.util.List;
-
-import static org.apache.rat.document.FSInfoTest.WINDOWS;
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ConvertersTest {
-
-    private static final DocumentName.FSInfo[] TEST_SUITE = FSInfoTest.TEST_SUITE;
-
-    @ParameterizedTest
-    @FieldSource("TEST_SUITE")
-    void convertFileNameTest(DocumentName.FSInfo fsInfo) {
-        String root = fsInfo.equals(WINDOWS) ? "D:\\" : fsInfo.roots()[0];
-        DocumentName workingDirectory = DocumentName.builder(fsInfo).setName("foo").setRoot(root).setBaseName("").build();
-        Converters.FILE_CONVERTER.setWorkingDirectory(workingDirectory);
-
-        for (String fn : List.of("rat.txt", "./rat.txt", "/rat.txt")) {
-            assertThat(Converters.FILE_CONVERTER.apply(fn).getName()).as(fn).isEqualTo(workingDirectory.getRoot() + fsInfo.mkPath("foo", "rat.txt"));
-        }
-
-        for (String fn : List.of("target/rat.txt", "./target/rat.txt", "/target/rat.txt")) {
-            assertThat(Converters.FILE_CONVERTER.apply(fn).getName()).as(fn).isEqualTo(workingDirectory.getRoot() + fsInfo.mkPath("foo", "target", "rat.txt"));
-        }
-    }
-
-}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index ae46ff2c7..f409fb666 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -80,7 +80,7 @@ public abstract class AbstractConfigurationOptionsProvider extends AbstractOptio
      */
     public static void preserveData(File baseDir, String targetDir) {
         final Path recordPath = FileSystems.getDefault().getPath("target", targetDir);
-        org.apache.rat.testhelpers.FileUtils.mkDir(recordPath.toFile());
+        org.apache.rat.utils.FileUtils.mkDir(recordPath.toFile());
         try {
             FileUtils.copyDirectory(baseDir, recordPath.toFile());
         } catch (IOException e) {
@@ -232,10 +232,10 @@ protected void inputExcludeParsedScmTest() {
 
         writeFile(".gitignore", Arrays.asList(lines));
         File dir = new File(baseDir, "red");
-        org.apache.rat.testhelpers.FileUtils.mkDir(dir);
+        org.apache.rat.utils.FileUtils.mkDir(dir);
         dir = new File(baseDir, "blue");
         dir = new File(dir, "fish");
-        org.apache.rat.testhelpers.FileUtils.mkDir(dir);
+        org.apache.rat.utils.FileUtils.mkDir(dir);
 
         assertDoesNotThrow(() -> {
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, args));

From 2605ddd53eaf20da65883cb7b6fdc81a12451fec Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Tue, 9 Jun 2026 14:45:38 +0100
Subject: [PATCH 23/36] fix DocumentName issues

---
 .../java/org/apache/rat/document/DocumentName.java     | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index c6cc55f22..ca6736599 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -625,6 +625,16 @@ private int compareData(final DocumentName.FSInfoData otherData) {
             return result;
         }
 
+        /**
+         * Creates a path separated by the directory separator.
+         * Starting with an empty string will cause the directory separateor to appear at the beginning.
+         * @param segments the segments that make up the path.
+         * @return the path string.
+         */
+        public String mkPath(final String... segments) {
+            return String.join(dirSeparator(), segments);
+        }
+
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);

From 862a8ad2f0c901d6b0e2d33ac5549802346a3221 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Tue, 16 Jun 2026 16:00:39 +0100
Subject: [PATCH 24/36] checkpoint

---
 .../ReportTest/RAT_406/src/dojo/dojo2.jav     |  7 +++
 .../apache/rat/ReporterOptionsProvider.java   |  2 +
 .../AbstractConfigurationOptionsProvider.java | 47 +++++++++++++++++++
 3 files changed, 56 insertions(+)
 create mode 100644 apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav

diff --git a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
new file mode 100644
index 000000000..f832e15d6
--- /dev/null
+++ b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
@@ -0,0 +1,7 @@
+/**
+ * DOJO flag
+ http://dojotoolkit.org/community/licensing.shtml
+ */
+interface dojo2 {
+
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index c81581fc1..9518c09ff 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -257,7 +257,9 @@ private void noDefaultsTest(final Option option) {
                 reporter.execute();
                 fail("Should have thrown exception");
             } catch (RatException e) {
+                ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
                 ClaimValidator validator = config.getClaimValidator();
+                assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
             }
         });
     }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index f409fb666..695c6cb7c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -599,6 +599,53 @@ Licensed to the Apache Software Foundation (ASF) under one or more
         return xmlPath.toString();
     }
 
+    private String writeConfigXML(String name) {
+        String licenseText = """
+                Licensed to the Apache Software Foundation (ASF) under one or more
+                       contributor license agreements.  See the NOTICE file distributed with
+                       this work for additional information regarding copyright ownership.
+                               The ASF licenses this file to You under the Apache License, Version 2.0
+                       (the "License"); you may not use this file except in compliance with
+                       the License.  You may obtain a copy of the License at
+                
+                       http://www.apache.org/licenses/LICENSE-2.0
+                
+                       Unless required by applicable law or agreed to in writing, software
+                       distributed under the License is distributed on an "AS IS" BASIS,
+                               WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+                               See the License for the specific language governing permissions and
+                       limitations under the License.""";
+        String capName = WordUtils.capitalize(name);
+        String upperName = name.toUpperCase(Locale.ROOT);
+
+        Path xmlPath = OptionCollectionTest.getTestPath().resolve(".rat/" + capName + ".xml");
+        File f = xmlPath.toFile();
+        try {
+            FileUtils.forceMkdir(f.getParentFile());
+            try (FileWriter writer = new FileWriter(f);
+                 XmlWriter xmlWriter = new XmlWriter(writer)) {
+
+                xmlWriter.startDocument()
+                        .comment(licenseText)
+                        .openElement("rat-config")
+                        .openElement("families")
+                        .openElement("family")
+                        .attribute("id", upperName)
+                        .attribute("name", "from " + capName + ".xml")
+                        .closeElement("families")
+                        .openElement("licenses")
+                        .openElement("license")
+                        .attribute("family", upperName)
+                        .openElement("text")
+                        .content(name)
+                        .closeElement("rat-config");
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return xmlPath.toString();
+    }
+
     private void configTest(final Option option) {
         String[] args = {writeConfigXML("one"), writeConfigXML("two")};
         Pair<Option, String[]> arg1 = ImmutablePair.of(option, args);

From febe704c82013b2f1485b5212a97bfcbf53f40a7 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Thu, 18 Jun 2026 13:49:48 +0100
Subject: [PATCH 25/36] Fixed several parsing errors in DocumentName.Builder
 Add testing Expanded testing to include multiple file system types Fix
 recursion issue in DocumentName equals and compareTo Additional migration to
 assertj Changed File options to return DocumentName instances. Cleaned up
 Sonar review issues

---
 .../ReportTest/RAT_406/src/dojo/dojo2.jav     |  7 ---
 .../AbstractConfigurationOptionsProvider.java | 47 -------------------
 2 files changed, 54 deletions(-)
 delete mode 100644 apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav

diff --git a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav b/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
deleted file mode 100644
index f832e15d6..000000000
--- a/apache-rat-core/src/it/resources/ReportTest/RAT_406/src/dojo/dojo2.jav
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
- * DOJO flag
- http://dojotoolkit.org/community/licensing.shtml
- */
-interface dojo2 {
-
-}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index 695c6cb7c..f409fb666 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -599,53 +599,6 @@ Licensed to the Apache Software Foundation (ASF) under one or more
         return xmlPath.toString();
     }
 
-    private String writeConfigXML(String name) {
-        String licenseText = """
-                Licensed to the Apache Software Foundation (ASF) under one or more
-                       contributor license agreements.  See the NOTICE file distributed with
-                       this work for additional information regarding copyright ownership.
-                               The ASF licenses this file to You under the Apache License, Version 2.0
-                       (the "License"); you may not use this file except in compliance with
-                       the License.  You may obtain a copy of the License at
-                
-                       http://www.apache.org/licenses/LICENSE-2.0
-                
-                       Unless required by applicable law or agreed to in writing, software
-                       distributed under the License is distributed on an "AS IS" BASIS,
-                               WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-                               See the License for the specific language governing permissions and
-                       limitations under the License.""";
-        String capName = WordUtils.capitalize(name);
-        String upperName = name.toUpperCase(Locale.ROOT);
-
-        Path xmlPath = OptionCollectionTest.getTestPath().resolve(".rat/" + capName + ".xml");
-        File f = xmlPath.toFile();
-        try {
-            FileUtils.forceMkdir(f.getParentFile());
-            try (FileWriter writer = new FileWriter(f);
-                 XmlWriter xmlWriter = new XmlWriter(writer)) {
-
-                xmlWriter.startDocument()
-                        .comment(licenseText)
-                        .openElement("rat-config")
-                        .openElement("families")
-                        .openElement("family")
-                        .attribute("id", upperName)
-                        .attribute("name", "from " + capName + ".xml")
-                        .closeElement("families")
-                        .openElement("licenses")
-                        .openElement("license")
-                        .attribute("family", upperName)
-                        .openElement("text")
-                        .content(name)
-                        .closeElement("rat-config");
-            }
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        return xmlPath.toString();
-    }
-
     private void configTest(final Option option) {
         String[] args = {writeConfigXML("one"), writeConfigXML("two")};
         Pair<Option, String[]> arg1 = ImmutablePair.of(option, args);

From 8917531c1ba112aff814c385ae1aec898c70e203 Mon Sep 17 00:00:00 2001
From: "P. Ottlinger" <pottlinger@apache.org>
Date: Tue, 23 Jun 2026 16:42:50 +0200
Subject: [PATCH 26/36] RAT-559: Refactor during review

---
 .../test/java/org/apache/rat/commandline/FileConverterTest.java  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
index 8213bbdb5..f1922638a 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/FileConverterTest.java
@@ -78,7 +78,6 @@ static List<Arguments> applyTestData() {
                 String root = fsInfo.roots()[1];
                 lst.add(Arguments.of(fsInfo, root + "foo/bar.txt", underTest, root + String.join(fsInfo.dirSeparator(), "foo", "bar.txt")));
                 lst.add(Arguments.of(fsInfo, root + "foo\\bar.txt", underTest, root + String.join(fsInfo.dirSeparator(), "foo", "bar.txt")));
-
             }
         }
         return lst;

From d9896beb8404c7131e9ba3cc73f9188b27823b05 Mon Sep 17 00:00:00 2001
From: "P. Ottlinger" <pottlinger@apache.org>
Date: Tue, 23 Jun 2026 17:15:53 +0200
Subject: [PATCH 27/36] RAT-559: Shorten tests

---
 .../AbstractConfigurationOptionsProvider.java | 47 -------------------
 1 file changed, 47 deletions(-)

diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index f409fb666..246729206 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -552,53 +552,6 @@ Licensed to the Apache Software Foundation (ASF) under one or more
         return xmlPath.toString();
     }
 
-    private String writeConfigXML(String name) {
-        String licenseText = """
-                Licensed to the Apache Software Foundation (ASF) under one or more
-                       contributor license agreements.  See the NOTICE file distributed with
-                       this work for additional information regarding copyright ownership.
-                               The ASF licenses this file to You under the Apache License, Version 2.0
-                       (the "License"); you may not use this file except in compliance with
-                       the License.  You may obtain a copy of the License at
-                
-                       http://www.apache.org/licenses/LICENSE-2.0
-                
-                       Unless required by applicable law or agreed to in writing, software
-                       distributed under the License is distributed on an "AS IS" BASIS,
-                               WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-                               See the License for the specific language governing permissions and
-                       limitations under the License.""";
-        String capName = WordUtils.capitalize(name);
-        String upperName = name.toUpperCase(Locale.ROOT);
-
-        Path xmlPath = this.baseDir.toPath().resolve(".rat/" + capName + ".xml");
-        File f = xmlPath.toFile();
-        try {
-            FileUtils.forceMkdir(f.getParentFile());
-            try (FileWriter writer = new FileWriter(f);
-                 XmlWriter xmlWriter = new XmlWriter(writer)) {
-
-                xmlWriter.startDocument()
-                        .comment(licenseText)
-                        .openElement("rat-config")
-                        .openElement("families")
-                        .openElement("family")
-                        .attribute("id", upperName)
-                        .attribute("name", "from " + capName + ".xml")
-                        .closeElement("families")
-                        .openElement("licenses")
-                        .openElement("license")
-                        .attribute("family", upperName)
-                        .openElement("text")
-                        .content(name)
-                        .closeElement("rat-config");
-            }
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        return xmlPath.toString();
-    }
-
     private void configTest(final Option option) {
         String[] args = {writeConfigXML("one"), writeConfigXML("two")};
         Pair<Option, String[]> arg1 = ImmutablePair.of(option, args);

From f3fd02e7618a727f3b1c82951f0cebb9691dfc6a Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Wed, 24 Jun 2026 17:32:15 +0100
Subject: [PATCH 28/36] fixed merge issues

---
 .../org/apache/rat/ReportConfiguration.java   | 19 +++++++--------
 .../config/exclusion/ExclusionProcessor.java  | 20 ++++++++--------
 .../rat/report/claim/ClaimStatistic.java      | 18 +++++++-------
 .../rat/testhelpers/data/DataUtils.java       | 24 +++++++++----------
 .../data/ReportTestDataProvider.java          |  4 ++--
 5 files changed, 42 insertions(+), 43 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index f6b2ccf7c..49ce6f18e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -65,7 +65,6 @@
 import org.apache.rat.report.IReportable;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.report.claim.ClaimStatistic;
-import org.apache.rat.report.xml.writer.IXmlWriter;
 import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log.Level;
@@ -890,8 +889,8 @@ public class Serde {
          * @throws IOException on error.
          */
         public void serialize(final Appendable appendable) throws IOException {
-            try (IXmlWriter writer = new XmlWriter(appendable)) {
-                writer.openElement("ReportConfiguration")
+            try (XmlWriter writer = new XmlWriter(appendable)) {
+                writer.startElement("ReportConfiguration")
                         .attribute("addingLicenses", Boolean.toString(addingLicenses))
                         .attribute("addingLicensesForced", Boolean.toString(addingLicensesForced))
                         .attribute("listFamilies", listFamilies.name())
@@ -902,15 +901,15 @@ public void serialize(final Appendable appendable) throws IOException {
                         .attribute("stylesheet", styleSheet.name())
                         .attribute("output", out.name());
                 if (StringUtils.isNotEmpty(copyrightMessage)) {
-                    writer.openElement("copyrightMessage").content(copyrightMessage).closeElement();
+                    writer.startElement("copyrightMessage").content(copyrightMessage).closeElement();
                 }
-                writer.openElement("sources");
+                writer.startElement("sources");
                 for (File f : sources) {
-                    writer.openElement("source").attribute("name", f.getName()).closeElement();
+                    writer.startElement("source").attribute("name", f.getName()).closeElement();
                 }
-                writer.closeElement("sources").openElement("reportables");
+                writer.closeElement("sources").startElement("reportables");
                 for (IReportable reportable : reportables) {
-                    writer.openElement("reportable")
+                    writer.startElement("reportable")
                             .attribute("baseName", reportable.name().getBaseName())
                             .attribute("name", reportable.name().toString())
                             .attribute("class", reportable.getClass().getName()).closeElement();
@@ -919,9 +918,9 @@ public void serialize(final Appendable appendable) throws IOException {
 
                 exclusionProcessor.serde().serialize(writer);
 
-                writer.openElement("claimValidator");
+                writer.startElement("claimValidator");
                 for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
-                    writer.openElement("claimCounter")
+                    writer.startElement("claimCounter")
                             .attribute("name", counter.name()).attribute("min", Integer.toString(claimValidator.getMin(counter)))
                             .attribute("max", Integer.toString(claimValidator.getMax(counter))).closeElement();
                 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 1ddce2e8a..6eb89aff4 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -33,7 +33,7 @@
 import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
-import org.apache.rat.report.xml.writer.IXmlWriter;
+import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.ExtendedIterator;
 import org.w3c.dom.Node;
@@ -351,31 +351,31 @@ private void extractPaths(final MatcherSet.Builder matcherBuilder) {
     }
 
     public class Serde {
-        public void serialize(final IXmlWriter writer) throws IOException {
-            writer.openElement("ExclusionProcessor");
+        public void serialize(final XmlWriter writer) throws IOException {
+            writer.startElement("ExclusionProcessor");
 
             for (String pattern : excludedPatterns) {
-                writer.openElement("excludedPattern").attribute("pattern", pattern).closeElement();
+                writer.startElement("excludedPattern").attribute("pattern", pattern).closeElement();
             }
             for (StandardCollection obj : excludedCollections) {
-                writer.openElement("excludedCollection").attribute("name", obj.name()).closeElement();
+                writer.startElement("excludedCollection").attribute("name", obj.name()).closeElement();
             }
             for (DocumentNameMatcher obj : excludedPaths) {
-                writer.openElement("excludedPath").attribute("name", obj.toString()).closeElement();
+                writer.startElement("excludedPath").attribute("name", obj.toString()).closeElement();
             }
 
             for (String pattern : includedPatterns) {
-                writer.openElement("includedPattern").attribute("pattern", pattern).closeElement();
+                writer.startElement("includedPattern").attribute("pattern", pattern).closeElement();
             }
             for (StandardCollection obj : includedCollections) {
-                writer.openElement("includedCollection").attribute("name", obj.name()).closeElement();
+                writer.startElement("includedCollection").attribute("name", obj.name()).closeElement();
             }
             for (DocumentNameMatcher obj : includedPaths) {
-                writer.openElement("includedPath").attribute("name", obj.toString()).closeElement();
+                writer.startElement("includedPath").attribute("name", obj.toString()).closeElement();
             }
 
             for (StandardCollection obj : fileProcessors) {
-                writer.openElement("fileProcessor").attribute("name", obj.name()).closeElement();
+                writer.startElement("fileProcessor").attribute("name", obj.name()).closeElement();
             }
             writer.closeElement();
 
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
index d47f2e5b7..5e3ff54fd 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
@@ -326,38 +326,38 @@ public class Serde {
 
         public void serialize(final Appendable appendable) throws IOException {
             try (XmlWriter writer = new XmlWriter(appendable)) {
-                writer.startDocument().openElement("ClaimStatistic")
-                        .openElement("licenseNameMap");
+                writer.startDocument().startElement("ClaimStatistic")
+                        .startElement("licenseNameMap");
                 for (Map.Entry<String, IntCounter> entry : licenseNameMap.entrySet()) {
                     if (entry.getValue().value > 0) {
-                        writer.openElement("licenseName")
+                        writer.startElement("licenseName")
                                 .attribute("count", entry.getValue().toString())
                                 .attribute("name", entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
-                        .openElement("licenseFamilyCategoryMap");
+                        .startElement("licenseFamilyCategoryMap");
                 for (Map.Entry<String, IntCounter> entry : licenseFamilyCategoryMap.entrySet()) {
                     if (entry.getValue().value > 0) {
-                        writer.openElement("familyCategory")
+                        writer.startElement("familyCategory")
                                 .attribute("count", entry.getValue().toString())
                                 .attribute("name", entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
-                        .openElement("documentTypeMap");
+                        .startElement("documentTypeMap");
                 for (Map.Entry<Document.Type, IntCounter> entry : documentTypeMap.entrySet()) {
                     if (entry.getValue().value > 0) {
-                        writer.openElement("documentType")
+                        writer.startElement("documentType")
                                 .attribute("count", entry.getValue().toString())
                                 .attribute("name", entry.getKey().name()).closeElement();
                     }
                 }
                 writer.closeElement()
-                        .openElement("counterMap");
+                        .startElement("counterMap");
                 for (Map.Entry<ClaimStatistic.Counter, IntCounter> entry : counterMap.entrySet()) {
                     if (entry.getValue().value > 0) {
-                        writer.openElement("counter")
+                        writer.startElement("counter")
                                 .attribute("count", entry.getValue().toString())
                                 .attribute("name", entry.getKey().name()).closeElement();
                     }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
index 11ad8ec87..3b570161d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/DataUtils.java
@@ -93,17 +93,17 @@ static void generateTextConfig(Path fileName, String id, String text) {
                         StandardCharsets.UTF_8))) {
             writer.startDocument()
                     .comment(ASF_TEXT)
-                    .openElement("rat-config")
-                    .openElement("families")
-                    .openElement("family")
+                    .startElement("rat-config")
+                    .startElement("families")
+                    .startElement("family")
                     .attribute("id", id)
                     .attribute("name", "from " + fileName.getFileName())
                     .closeElement() // family
                     .closeElement() // families
-                    .openElement("licenses")
-                    .openElement("license")
+                    .startElement("licenses")
+                    .startElement("license")
                     .attribute("family", id)
-                    .openElement("text")
+                    .startElement("text")
                     .content(text)
                     .closeDocument(); // close all open elements
         } catch (IOException e) {
@@ -122,17 +122,17 @@ static void generateSpdxConfig(Path fileName, String id, String spdxId) {
                 StandardCharsets.UTF_8))) {
             writer.startDocument()
                     .comment(ASF_TEXT)
-                    .openElement("rat-config")
-                    .openElement("families")
-                    .openElement("family")
+                    .startElement("rat-config")
+                    .startElement("families")
+                    .startElement("family")
                     .attribute("id", id)
                     .attribute("name", "from " + fileName.getFileName())
                     .closeElement() // family
                     .closeElement() // families
-                    .openElement("licenses")
-                    .openElement("license")
+                    .startElement("licenses")
+                    .startElement("license")
                     .attribute("family", id)
-                    .openElement("spdx")
+                    .startElement("spdx")
                     .attribute("name", spdxId)
                     .closeDocument(); // close all open elements
         } catch (IOException e) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
index 62a0ab968..88f78bc35 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
@@ -1252,10 +1252,10 @@ protected void outputStyleTest(final Set<TestData> result, final Option option)
                              XmlWriter writer = new XmlWriter(fileWriter)) {
                             writer.startDocument()
                                     .comment(DataUtils.ASF_TEXT)
-                                    .openElement("xsl:stylesheet")
+                                    .startElement("xsl:stylesheet")
                                     .attribute("version", "1.0")
                                     .attribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform")
-                                    .openElement("xsl:template")
+                                    .startElement("xsl:template")
                                     .attribute("match", "@*|node()")
                                     .content("Hello World")
                                     .closeDocument();

From c484029b2d8a20416b0f833541b4c65781a5a49f Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Thu, 25 Jun 2026 11:06:18 +0100
Subject: [PATCH 29/36] fixed rebase issues

---
 .../org/apache/rat/document/DocumentName.java |  10 --
 .../apache/rat/ReporterOptionsProvider.java   |  13 +-
 .../rat/report/claim/ClaimStatisticTest.java  | 139 ++++++++++++++++++
 .../writer/{impl/base => }/XmlWriterTest.java |   5 +-
 4 files changed, 144 insertions(+), 23 deletions(-)
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
 rename apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/{impl/base => }/XmlWriterTest.java (98%)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
index ca6736599..c6cc55f22 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/document/DocumentName.java
@@ -625,16 +625,6 @@ private int compareData(final DocumentName.FSInfoData otherData) {
             return result;
         }
 
-        /**
-         * Creates a path separated by the directory separator.
-         * Starting with an empty string will cause the directory separateor to appear at the beginning.
-         * @param segments the segments that make up the path.
-         * @return the path string.
-         */
-        public String mkPath(final String... segments) {
-            return String.join(dirSeparator(), segments);
-        }
-
         @Override
         public int compareTo(final FSInfo other) {
             int result = this.name.compareToIgnoreCase(other.name);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 9518c09ff..0d0e99425 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -68,6 +68,7 @@
 
 import static org.apache.rat.commandline.Arg.HELP_LICENSES;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Fail.fail;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
@@ -250,17 +251,11 @@ private void noDefaultsTest(final Option option) {
                     "*/\n\n", "class Test {}\n"));
 
             validateNoArgSetup();
-
             ReportConfiguration config = generateConfig(ImmutablePair.of(option, null));
             Reporter reporter = new Reporter(config);
-            try {
-                reporter.execute();
-                fail("Should have thrown exception");
-            } catch (RatException e) {
-                ClaimStatistic claimStatistic = reporter.getClaimsStatistic();
-                ClaimValidator validator = config.getClaimValidator();
-                assertThat(validator.listIssues(claimStatistic)).containsExactlyInAnyOrder("DOCUMENT_TYPES", "LICENSE_CATEGORIES", "LICENSE_NAMES", "STANDARDS");
-            }
+            assertThatThrownBy(reporter::execute)
+                    .isInstanceOf(RatException.class)
+                            .hasMessageContaining("At least one license must be defined");
         });
     }
 
diff --git a/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
new file mode 100644
index 000000000..c2bd6f1ee
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat.report.claim;
+
+import org.apache.rat.api.Document;
+import org.junit.jupiter.api.Test;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ClaimStatisticTest {
+
+    @Test
+    void counterTests() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
+        underTest.incCounter(ClaimStatistic.Counter.APPROVED, 1);
+        assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
+        underTest.incCounter(ClaimStatistic.Counter.APPROVED, -2);
+        assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(-1);
+        underTest.setCounter(ClaimStatistic.Counter.APPROVED, Integer.MAX_VALUE);
+        assertThat(underTest.getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(Integer.MAX_VALUE);
+    }
+
+    @Test
+    void typeTests() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getCounter(Document.Type.NOTICE)).isZero();
+        underTest.incCounter(Document.Type.NOTICE, 1);
+        assertThat(underTest.getCounter(Document.Type.NOTICE)).isEqualTo(1);
+        underTest.incCounter(Document.Type.NOTICE, -2);
+        assertThat(underTest.getCounter(Document.Type.NOTICE)).isEqualTo(-1);
+    }
+
+    @Test
+    void documentTypeTest() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getDocumentTypes()).isEmpty();
+        underTest.incCounter(Document.Type.NOTICE, 1);
+        underTest.incCounter(Document.Type.BINARY, -1);
+        assertThat(underTest.getDocumentTypes()).containsExactly(Document.Type.BINARY, Document.Type.NOTICE);
+    }
+
+    @Test
+    void licenseCategoryCountTest() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getLicenseCategoryCount("fam")).isZero();
+        underTest.incLicenseCategoryCount("fam", 1);
+        assertThat(underTest.getLicenseCategoryCount("fam")).isEqualTo(1);
+        underTest.incLicenseCategoryCount("fam", -2);
+        assertThat(underTest.getLicenseCategoryCount("fam")).isEqualTo(-1);
+        underTest.incLicenseCategoryCount("wayToLongAName", 5);
+        assertThat(underTest.getLicenseCategoryCount("wayToLongAName")).isEqualTo(5);
+    }
+
+    @Test
+    void licenseNameCountTest() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getLicenseNameCount("fam")).isZero();
+        underTest.incLicenseNameCount("fam", 1);
+        assertThat(underTest.getLicenseNameCount("fam")).isEqualTo(1);
+        underTest.incLicenseNameCount("fam", -2);
+        assertThat(underTest.getLicenseNameCount("fam")).isEqualTo(-1);
+    }
+
+    @Test
+    void licenseFamilyCategoriesTest() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getLicenseFamilyCategories()).isEmpty();
+        underTest.incLicenseCategoryCount("one", 1);
+        underTest.incLicenseCategoryCount("neg", -1);
+        assertThat(underTest.getLicenseFamilyCategories()).containsExactly("neg", "one");
+        underTest.incLicenseCategoryCount("wayToLongAName", 5);
+        assertThat(underTest.getLicenseFamilyCategories()).containsExactly("neg", "one", "wayToLongAName");
+    }
+
+    @Test
+    void licenseFamilyNameTest() {
+        ClaimStatistic underTest = new ClaimStatistic();
+        assertThat(underTest.getLicenseNames()).isEmpty();
+        underTest.incLicenseNameCount("one", 1);
+        underTest.incLicenseNameCount("neg", -1);
+        assertThat(underTest.getLicenseNames()).containsExactly("neg", "one");
+        underTest.incLicenseNameCount("wayToLongAName", 5);
+        assertThat(underTest.getLicenseNames()).containsExactly("neg", "one", "wayToLongAName");
+    }
+
+
+    @Test
+    void serdeRoundTrip() throws IOException {
+        ClaimStatistic underTest = new ClaimStatistic();
+        underTest.incLicenseCategoryCount("familyCagegory", 1);
+        underTest.incCounter(ClaimStatistic.Counter.APPROVED, 2);
+        underTest.incCounter(Document.Type.IGNORED, 3);
+        underTest.incLicenseNameCount("licenseName", 4);
+
+        ClaimStatistic.Serde serde = underTest.serde();
+        StringWriter stringWriter = new StringWriter();
+        serde.serialize(stringWriter);
+        ClaimStatistic actual = new ClaimStatistic();
+        ClaimStatistic.Serde serde2 = actual.serde();
+        serde2.deserialize(() -> new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
+
+        assertThat(actual.getLicenseFamilyCategories()).containsExactlyElementsOf(underTest.getLicenseFamilyCategories());
+        assertThat(actual.getLicenseNames()).containsExactlyElementsOf(underTest.getLicenseNames());
+        assertThat(actual.getDocumentTypes()).containsExactlyElementsOf(underTest.getDocumentTypes());
+        for (String cat : underTest.getLicenseFamilyCategories()) {
+            assertThat(actual.getLicenseCategoryCount(cat)).isEqualTo(underTest.getLicenseCategoryCount(cat));
+        }
+        for (String name : underTest.getLicenseNames()) {
+            assertThat(actual.getLicenseNameCount(name)).isEqualTo(underTest.getLicenseNameCount(name));
+        }
+        for (Document.Type type : underTest.getDocumentTypes()) {
+            assertThat(actual.getCounter(type)).isEqualTo(underTest.getCounter(type));
+        }
+        for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+            assertThat(actual.getCounter(counter)).isEqualTo(underTest.getCounter(counter));
+        }
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java b/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
similarity index 98%
rename from apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java
rename to apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
index 287db7677..b86ad72f0 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/impl/base/XmlWriterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/report/xml/writer/XmlWriterTest.java
@@ -16,11 +16,8 @@
  * specific language governing permissions and limitations      *
  * under the License.                                           *
  */ 
-package org.apache.rat.report.xml.writer.impl.base;
+package org.apache.rat.report.xml.writer;
 
-import org.apache.rat.report.xml.writer.InvalidXmlException;
-import org.apache.rat.report.xml.writer.OperationNotAllowedException;
-import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.testhelpers.XmlUtils;
 import org.junit.jupiter.api.Test;
 import org.w3c.dom.Document;

From b15b06b23e6a39135e57e499b0e328a43ba9adf5 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Thu, 25 Jun 2026 22:04:50 +0100
Subject: [PATCH 30/36] fix some sonarqube issues

---
 .../config/exclusion/ExclusionProcessor.java  |  62 +++++-
 .../exclusion/ExclusionProcessorTest.java     | 198 ++++++++++++++++++
 2 files changed, 252 insertions(+), 8 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 6eb89aff4..37865a4de 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -20,6 +20,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -64,8 +65,10 @@ public class ExclusionProcessor {
     /** Standard collections that contribute to the exclusion procession */
     private final Set<StandardCollection> excludedCollections;
     /** The last generated PathMatcher */
+    // package private for testing
     private DocumentNameMatcher lastMatcher;
     /** The base dir for the last PathMatcher */
+    // package private for testing
     private DocumentName lastMatcherBaseDir;
 
     /**
@@ -85,6 +88,44 @@ public Serde serde() {
         return new Serde();
     }
 
+    /* the folloing set of methods are here for testing purposes */
+
+    Set<String> getExcludedPatterns() {
+        return new HashSet(excludedPatterns);
+    }
+
+    Collection<DocumentNameMatcher> getExcludedPaths() {
+        return new ArrayList(excludedPaths);
+    }
+
+    Set<String> getIncludedPatterns() {
+        return new HashSet<>(includedPatterns);
+    }
+
+    Collection<DocumentNameMatcher> getIncludedPaths() {
+        return new ArrayList(includedPaths);
+    }
+
+    Collection<StandardCollection> getFileProcessors() {
+        return new HashSet<>(fileProcessors);
+    }
+
+    Set<StandardCollection> getIncludedCollections() {
+        return new HashSet(includedCollections);
+    }
+
+    Set<StandardCollection> getExcludedCollections() {
+        return new HashSet(excludedCollections);
+    }
+
+    DocumentNameMatcher getLastMatcher() {
+        return lastMatcher;
+    }
+
+    DocumentName getLastMatcherBaseDir() {
+        return lastMatcherBaseDir;
+    };
+
     /**
      * Reset the {@link #lastMatcher} and {@link #lastMatcherBaseDir} to start again
      */
@@ -99,9 +140,11 @@ private void resetLastMatcher() {
      * @return this
      */
     public ExclusionProcessor addIncludedPatterns(final Iterable<String> patterns) {
-        DefaultLog.getInstance().debug(format("Including patterns: %s", String.join(", ", patterns)));
-        patterns.forEach(includedPatterns::add);
-        resetLastMatcher();
+        if (patterns != null) {
+            DefaultLog.getInstance().debug(format("Including patterns: %s", String.join(", ", patterns)));
+            patterns.forEach(includedPatterns::add);
+            resetLastMatcher();
+        }
         return this;
     }
 
@@ -152,9 +195,11 @@ public ExclusionProcessor addIncludedCollection(final StandardCollection collect
      * @return this
      */
     public ExclusionProcessor addExcludedPatterns(final Iterable<String> patterns) {
-        DefaultLog.getInstance().debug(format("Excluding patterns: %s", String.join(", ", patterns)));
-        patterns.forEach(excludedPatterns::add);
-        resetLastMatcher();
+        if (patterns != null) {
+            DefaultLog.getInstance().debug(format("Excluding patterns: %s", String.join(", ", patterns)));
+            patterns.forEach(excludedPatterns::add);
+            resetLastMatcher();
+        }
         return this;
     }
 
@@ -190,9 +235,11 @@ public void reportExclusions(final Appendable appendable) throws IOException {
         for (DocumentNameMatcher nameMatcher : excludedPaths) {
             appendable.append(format("Excluding %s.%n", nameMatcher.toString()));
         }
+        for (DocumentNameMatcher nameMatcher : includedPaths) {
+            appendable.append(format("Including %s.%n", nameMatcher.toString()));
+        }
     }
 
-
     /**
      * Excludes the files/directories specified by a StandardCollection.
      * @param collection the StandardCollection that identifies the files to exclude.
@@ -417,7 +464,6 @@ public void deserialize(final Node n) {
                     default:
                         throw new NotImplementedException("Deserialization for %s is not implemented", child.getNodeName());
                 }
-
             }
         }
     }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
index 19e2e1542..10b3e54a6 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
@@ -18,6 +18,9 @@
  */
 package org.apache.rat.config.exclusion;
 
+import java.io.ByteArrayInputStream;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.FileSystems;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -26,6 +29,11 @@
 import org.apache.commons.io.FileUtils;
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.document.DocumentName;
+import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.testhelpers.TextUtils;
+import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.utils.StandardXmlFactory;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
 import java.io.File;
@@ -37,6 +45,8 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
 
 import static java.lang.String.format;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -264,4 +274,192 @@ private static Stream<Arguments> getDocumentNames() {
 
         return lst.stream();
     }
+
+    @Test
+    void addNullIncludedMatcherTest() {
+        ExclusionProcessor underTest = new ExclusionProcessor();
+        assertThat(underTest.getIncludedPaths()).isEmpty();
+                underTest.addIncludedMatcher(null);
+                assertThat(underTest.getIncludedPaths()).isEmpty();
+                underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+                        .addIncludedMatcher(null);
+        assertThat(underTest.getIncludedPaths()).hasSize(1);
+        List<String> actualPaths = underTest.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).containsExactly(DocumentNameMatcher.MATCHES_ALL.toString());
+    }
+
+    @Test
+    void addNullExcludedMatcherTest() {
+        ExclusionProcessor underTest = new ExclusionProcessor();
+        assertThat(underTest.getExcludedPaths()).isEmpty();
+        underTest.addExcludedMatcher(null);
+        assertThat(underTest.getExcludedPaths()).isEmpty();
+        underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+                .addExcludedMatcher(null);
+        assertThat(underTest.getExcludedPaths()).hasSize(1);
+        List<String> actualPaths = underTest.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).containsExactly(DocumentNameMatcher.MATCHES_ALL.toString());
+    }
+
+    @Test
+    void addFileProcessor() {
+        ExclusionProcessor underTest = new ExclusionProcessor();
+        assertThat(underTest.getFileProcessors()).isEmpty();
+        underTest.addFileProcessor(null);
+        assertThat(underTest.getFileProcessors()).isEmpty();
+        underTest.addFileProcessor(StandardCollection.HIDDEN_FILE)
+                .addFileProcessor(null);
+        assertThat(underTest.getFileProcessors()).containsExactly(StandardCollection.HIDDEN_FILE);
+    }
+
+    @Test
+    void addNullIncludedPatternTest() {
+        ExclusionProcessor underTest = new ExclusionProcessor();
+        assertThat(underTest.getIncludedPatterns()).isEmpty();
+        underTest.addIncludedPatterns(null);
+        assertThat(underTest.getIncludedPatterns()).isEmpty();
+        underTest.addIncludedPatterns(Collections.emptyList());
+        assertThat(underTest.getIncludedPatterns()).isEmpty();
+        underTest.addIncludedPatterns(List.of("hello/world"))
+        .addIncludedPatterns(null)
+                .addIncludedPatterns(Collections.emptyList());
+        assertThat(underTest.getIncludedPatterns()).containsExactly("hello/world");
+    }
+
+    @Test
+    void addNullExcludedPatternTest() {
+        ExclusionProcessor underTest = new ExclusionProcessor();
+        assertThat(underTest.getExcludedPatterns()).isEmpty();
+        underTest.addExcludedPatterns(null);
+        assertThat(underTest.getExcludedPatterns()).isEmpty();
+        underTest.addExcludedPatterns(Collections.emptyList());
+        assertThat(underTest.getExcludedPatterns()).isEmpty();
+        underTest.addExcludedPatterns(List.of("hello/world"))
+                .addExcludedPatterns(null)
+                .addExcludedPatterns(Collections.emptyList());
+        assertThat(underTest.getExcludedPatterns()).containsExactly("hello/world");
+    }
+
+    @ParameterizedTest
+    @MethodSource("serdeTestData")
+    void serdeTest(ExclusionProcessor underTest) throws IOException, SAXException {
+        StringWriter stringWriter = new StringWriter();
+        try (XmlWriter writer = new XmlWriter(stringWriter)) {
+            underTest.serde().serialize(writer);
+        }
+        Document document = StandardXmlFactory.documentBuilder().parse(new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
+        ExclusionProcessor actual = new ExclusionProcessor();
+        actual.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
+        assertThat(actual.getExcludedCollections()).containsExactlyElementsOf(underTest.getExcludedCollections());
+        assertThat(actual.getFileProcessors()).containsExactlyElementsOf(underTest.getFileProcessors());
+        assertThat(actual.getIncludedCollections()).containsExactlyElementsOf(underTest.getIncludedCollections());
+        assertThat(actual.getExcludedPatterns()).containsExactlyElementsOf(underTest.getExcludedPatterns());
+        assertThat(actual.getIncludedPatterns()).containsExactlyElementsOf(underTest.getIncludedPatterns());
+
+        // paths only match on name.  deserialized paths are not functional.
+        List<String> actualPaths = actual.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        List<String> expectedPaths = underTest.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).as("excluded paths").containsExactlyElementsOf(expectedPaths);
+
+        actualPaths = actual.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        expectedPaths = underTest.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).as("included paths").containsExactlyElementsOf(expectedPaths);
+    }
+
+    static List<ExclusionProcessor> serdeTestData() {
+        List<ExclusionProcessor> tests = new ArrayList<>();
+        tests.add(new ExclusionProcessor());
+
+        // single exclusions
+        tests.add(new ExclusionProcessor()
+        .addExcludedPatterns(List.of("pattern/**")));
+
+        tests.add(new ExclusionProcessor()
+       .addExcludedCollection(StandardCollection.BAZAAR));
+
+
+        tests.add(new ExclusionProcessor()
+        .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL));
+
+        // single inclusions
+        tests.add(new ExclusionProcessor()
+        .addIncludedPatterns(List.of("pattern/**")));
+
+        tests.add(new ExclusionProcessor()
+        .addIncludedCollection(StandardCollection.BAZAAR));
+
+        tests.add(new ExclusionProcessor()
+        .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE));
+
+        // full population
+        tests.add(new ExclusionProcessor()
+        .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+        .addExcludedCollection(StandardCollection.BAZAAR)
+        .addExcludedCollection(StandardCollection.MISC)
+        .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+        .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+                .addIncludedCollection(StandardCollection.ARCH)
+                .addIncludedCollection(StandardCollection.BITKEEPER)
+        .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE));
+
+        return tests;
+    }
+
+    @Test
+    void reportExclusionsTest() throws IOException, SAXException {
+        ExclusionProcessor underTest = new ExclusionProcessor()
+                .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+                .addExcludedCollection(StandardCollection.BAZAAR)
+                .addExcludedCollection(StandardCollection.MISC)
+                .addFileProcessor(StandardCollection.HIDDEN_FILE)
+                .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+                .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+                .addIncludedCollection(StandardCollection.ARCH)
+                .addIncludedCollection(StandardCollection.BITKEEPER)
+                .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+        StringWriter writer = new StringWriter();
+        underTest.reportExclusions(writer);
+        String actual = writer.toString();
+
+        TextUtils.assertPatternInTarget("Excluding patterns:[^$]+\\Qpattern/**\\E", actual);
+        TextUtils.assertPatternInTarget("Excluding patterns:[^$]+\\Qpattern2/**\\E", actual);
+        TextUtils.assertPatternInTarget("Including patterns:[^$]+\\Q**/pattern3\\E", actual);
+        TextUtils.assertPatternInTarget("Including patterns:[^$]+\\Q**/pattern4\\E", actual);
+        assertThat(actual).contains("Excluding " + StandardCollection.BAZAAR + " collection.");
+        assertThat(actual).contains("Excluding " + StandardCollection.MISC + " collection.");
+        assertThat(actual).contains("Including " + StandardCollection.ARCH + " collection.");
+        assertThat(actual).contains("Including " + StandardCollection.BITKEEPER + " collection.");
+        assertThat(actual).contains("Processing exclude file from " + StandardCollection.HIDDEN_FILE);
+        assertThat(actual).contains("Excluding " + DocumentNameMatcher.MATCHES_ALL + ".");
+        assertThat(actual).contains("Including " + DocumentNameMatcher.MATCHES_NONE + ".");
+    }
+
+    @Test
+    void getNameMatcherTest() {
+        ExclusionProcessor underTest = new ExclusionProcessor()
+                .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
+                .addExcludedCollection(StandardCollection.BAZAAR)
+                .addExcludedCollection(StandardCollection.MISC)
+                .addFileProcessor(StandardCollection.HIDDEN_FILE)
+                .addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL)
+                .addIncludedPatterns(List.of("**/pattern3", "**/pattern4"))
+                .addIncludedCollection(StandardCollection.ARCH)
+                .addIncludedCollection(StandardCollection.BITKEEPER)
+                .addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+        assertThat(underTest.getLastMatcherBaseDir()).isNull();
+        assertThat(underTest.getLastMatcher()).isNull();
+        DocumentName base = DocumentName.builder(new File(".")).build();
+
+        DocumentNameMatcher matcher = underTest.getNameMatcher(base);
+        assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+        assertThat(underTest.getLastMatcher()).isEqualTo(matcher);
+
+        DocumentNameMatcher matcher2 = underTest.getNameMatcher(base);
+        assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+        assertThat(underTest.getLastMatcher()).isEqualTo(matcher);
+        assertThat(underTest.getLastMatcherBaseDir()).isEqualTo(base);
+        assertThat(matcher2).isEqualTo(matcher);
+    }
 }

From f4939c2c85d53b7e7d999e01c1829ffb1cc9b3ed Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Fri, 26 Jun 2026 08:33:56 +0100
Subject: [PATCH 31/36] cleaned up sonar issues

---
 .../org/apache/rat/report/{IReportable.java => Reportable.java}   | 0
 .../{IReportableListWalker.java => ReportableListWalker.java}     | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename apache-rat-core/src/main/java/org/apache/rat/report/{IReportable.java => Reportable.java} (100%)
 rename apache-rat-core/src/main/java/org/apache/rat/walker/{IReportableListWalker.java => ReportableListWalker.java} (100%)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java b/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
similarity index 100%
rename from apache-rat-core/src/main/java/org/apache/rat/report/IReportable.java
rename to apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
similarity index 100%
rename from apache-rat-core/src/main/java/org/apache/rat/walker/IReportableListWalker.java
rename to apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java

From 42aeae65d41a89d5a34242f2dc2dcfed9f76415e Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Fri, 26 Jun 2026 08:38:56 +0100
Subject: [PATCH 32/36] fixed sonar issues

---
 .../java/org/apache/rat/OptionCollection.java |   6 +-
 .../apache/rat/OptionCollectionParser.java    |  40 ++---
 .../src/main/java/org/apache/rat/Report.java  |   3 +-
 .../org/apache/rat/ReportConfiguration.java   |  30 ++--
 .../main/java/org/apache/rat/Reporter.java    |  14 +-
 .../config/exclusion/ExclusionProcessor.java  |  31 ++--
 .../apache/rat/license/LicenseSetFactory.java |   2 +-
 .../org/apache/rat/report/Reportable.java     |   2 +-
 .../rat/report/claim/ClaimStatistic.java      |  38 +++--
 .../java/org/apache/rat/utils/FileUtils.java  |   5 +-
 .../org/apache/rat/walker/FileListWalker.java |   4 +-
 .../rat/walker/ReportableListWalker.java      |  18 +--
 .../java/org/apache/rat/walker/Walker.java    |   4 +-
 .../rat/OptionCollectionParserTest.java       |   3 +-
 .../org/apache/rat/OptionCollectionTest.java  |   9 +-
 .../apache/rat/ReportConfigurationTest.java   | 144 +++++++++++++++++-
 .../apache/rat/ReporterOptionsProvider.java   |  30 ++--
 .../java/org/apache/rat/ReporterTest.java     |   7 -
 .../org/apache/rat/commandline/ArgTests.java  |   1 -
 .../exclusion/ExclusionProcessorTest.java     |  25 ++-
 .../XMLConfigurationReaderTest.java           |   2 +-
 .../AbstractConfigurationOptionsProvider.java |   9 +-
 .../rat/testhelpers/BaseOptionCollection.java |   2 +-
 .../org/apache/rat/testhelpers/TextUtils.java |   6 +
 .../data/AbstractTestDataProvider.java        |  10 +-
 .../data/ReportTestDataProvider.java          |  36 ++---
 .../java/org/apache/rat/mp/RatCheckMojo.java  |   6 +-
 .../java/org/apache/rat/anttasks/Report.java  |   2 +-
 .../anttasks/ResourceCollectionContainer.java |   4 +-
 29 files changed, 314 insertions(+), 179 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
index 9130d6258..d3531b59a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollection.java
@@ -47,7 +47,7 @@
 import org.apache.rat.document.FileDocument;
 import org.apache.rat.help.Licenses;
 import org.apache.rat.license.LicenseSetFactory;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log.Level;
@@ -184,7 +184,7 @@ public static ReportConfiguration createConfiguration(final ArgumentContext argu
             }
         }
         for (String s : commandLine.getArgs()) {
-            IReportable reportable = getReportable(new File(s), configuration);
+            Reportable reportable = getReportable(new File(s), configuration);
             if (reportable != null) {
                 configuration.addSource(reportable);
             }
@@ -209,7 +209,7 @@ public static Options buildOptions() {
      * @param config the ReportConfiguration.
      * @return the IReportable instance containing the files.
      */
-    public static IReportable getReportable(final File base, final ReportConfiguration config) {
+    public static Reportable getReportable(final File base, final ReportConfiguration config) {
         File absBase = base.getAbsoluteFile();
         DocumentName documentName = DocumentName.builder(absBase).build();
         if (!absBase.exists()) {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
index db75e3eec..6e76d035a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
@@ -31,10 +31,11 @@
 import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.Arg;
 import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.help.Licenses;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.ui.UIOptionCollection;
 import org.apache.rat.utils.DefaultLog;
 
@@ -61,11 +62,10 @@ public OptionCollectionParser(final UIOptionCollection<?> optionCollection) {
      * @param workingDirectory The directory to resolve relative file names against.
      * @param args the arguments to parse
      * @return the ArgumentContext for the process.
-     * @throws IOException on error.
-     * @throws ParseException on option parsing error.
+     * @throws RatException on error.
      */
     public ArgumentContext parseCommands(final File workingDirectory, final String[] args)
-            throws IOException, ParseException {
+            throws RatException {
         return parseCommands(workingDirectory, args, uiOptionCollection.getOptions());
     }
 
@@ -94,21 +94,27 @@ public static CommandLine parseCommandLine(final Options opts, final String[] ar
      * @param args the arguments to parse.
      * @param options An Options object containing Apache command line options.
      * @return the ArgumentContext for the process.
-     * @throws IOException on error.
-     * @throws ParseException on option parsing error.
+     * @throws RatException on error.
      */
     private ArgumentContext parseCommands(final File workingDirectory, final String[] args,
-                                                                       final Options options) throws IOException, ParseException {
-        ArgumentContext argumentContext = new ArgumentContext(workingDirectory, options, args);
-        Arg.processLogLevel(argumentContext, uiOptionCollection);
-        populateConfiguration(argumentContext);
-        if (uiOptionCollection.isSelected(Arg.HELP_LICENSES)) {
-            new Licenses(argumentContext.getConfiguration(),
-                    new PrintWriter(argumentContext.getConfiguration().getOutput().get(),
-                            false, StandardCharsets.UTF_8)).printHelp();
+                                                                       final Options options) throws RatException {
+        try {
+            ArgumentContext argumentContext = new ArgumentContext(workingDirectory, options, args);
+            Arg.processLogLevel(argumentContext, uiOptionCollection);
+            populateConfiguration(argumentContext);
+            if (uiOptionCollection.isSelected(Arg.HELP_LICENSES)) {
+                try {
+                    new Licenses(argumentContext.getConfiguration(),
+                            new PrintWriter(argumentContext.getConfiguration().getOutput().get(),
+                                    false, StandardCharsets.UTF_8)).printHelp();
+                } catch (IOException e) {
+                    throw new RatException("Unable to print help: " + e.getMessage(), e);
+                }
+            }
+            return argumentContext;
+        } catch (ParseException e) {
+            throw new RatException("Unable to parse command line: " + e.getMessage(), e);
         }
-
-        return argumentContext;
     }
 
     /**
@@ -124,7 +130,7 @@ private ReportConfiguration populateConfiguration(final ArgumentContext argument
         final CommandLine commandLine = argumentContext.getCommandLine();
         if (!configuration.hasSource()) {
             for (String s : commandLine.getArgs()) {
-                IReportable reportable = OptionCollection.getReportable(new File(s), configuration);
+                Reportable reportable = OptionCollection.getReportable(new File(s), configuration);
                 if (reportable != null) {
                     configuration.addSource(reportable);
                 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Report.java b/apache-rat-core/src/main/java/org/apache/rat/Report.java
index ce019b782..a7be90a03 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Report.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Report.java
@@ -26,6 +26,7 @@
 
 import org.apache.commons.cli.Options;
 import org.apache.commons.io.function.IOSupplier;
+import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.document.RatDocumentAnalysisException;
 import org.apache.rat.help.Help;
@@ -88,7 +89,7 @@ private static void printUsage(final Options options, final IOSupplier<OutputStr
      * @return The Client output.
      * @throws Exception on error.
      */
-    static Reporter.Output generateReport(final CLIOptionCollection optionCollection, final File workingDirectory, final String[] args) throws Exception {
+    static Reporter.Output generateReport(final CLIOptionCollection optionCollection, final File workingDirectory, final String[] args) throws RatException {
         Reporter.Output output = null;
         OptionCollectionParser optionParser = new OptionCollectionParser(optionCollection);
         ArgumentContext argumentContext = optionParser.parseCommands(workingDirectory, args);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index 49ce6f18e..97fb3b049 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -62,15 +62,16 @@
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.DefaultLog;
 import org.apache.rat.utils.Log.Level;
 import org.apache.rat.utils.ReportingSet;
+import org.apache.rat.utils.StandardXmlFactory;
 import org.apache.rat.walker.FileListWalker;
-import org.apache.rat.walker.IReportableListWalker;
+import org.apache.rat.walker.ReportableListWalker;
 import org.w3c.dom.Node;
 import org.xml.sax.SAXException;
 
@@ -84,7 +85,9 @@
 public class ReportConfiguration {
 
     /** The IODescriptor for System.out */
-    public static final IODescriptor<OutputStream> SYSTEM_OUT = new  IODescriptor<>("System.out", () -> CloseShieldOutputStream.wrap(System.out));
+    public static final IODescriptor<OutputStream> SYSTEM_OUT =
+            // SONAR wants to require logging output, which is the wrong reporting channel for this case.
+            new IODescriptor<>("System.out", () -> CloseShieldOutputStream.wrap(System.out)); // NOSONAR
     /**
      * The styles of processing for various categories of documents.
      */
@@ -148,7 +151,7 @@ public String desc() {
     /**
      * A list of reportables to process;
      */
-    private final List<IReportable> reportables;
+    private final List<Reportable> reportables;
 
     /**
      * A predicate to test if a path should be included in the processing.
@@ -231,7 +234,7 @@ private void notNull(final Object o, final String msg) {
      * Adds a Reportable as a source of files to scan.
      * @param reportable the reportable to process.
      */
-    public void addSource(final IReportable reportable) {
+    public void addSource(final Reportable reportable) {
         notNull(reportable, "Reportable may not be null.");
         reportables.add(reportable);
     }
@@ -248,9 +251,9 @@ public boolean hasSource() {
      * Gets a builder initialized with any files specified as sources.
      * @return a configured builder.
      */
-    public IReportableListWalker.Builder getSources() {
+    public ReportableListWalker.Builder getSources() {
         DocumentName name = DocumentName.builder(new File(".")).build();
-        IReportableListWalker.Builder builder = IReportableListWalker.builder(name);
+        ReportableListWalker.Builder builder = ReportableListWalker.builder(name);
         sources.forEach(file -> builder.addReportable(new FileListWalker(new FileDocument(file, DocumentNameMatcher.MATCHES_ALL))));
         reportables.forEach(builder::addReportable);
         return builder;
@@ -908,7 +911,7 @@ public void serialize(final Appendable appendable) throws IOException {
                     writer.startElement("source").attribute("name", f.getName()).closeElement();
                 }
                 writer.closeElement("sources").startElement("reportables");
-                for (IReportable reportable : reportables) {
+                for (Reportable reportable : reportables) {
                     writer.startElement("reportable")
                             .attribute("baseName", reportable.name().getBaseName())
                             .attribute("name", reportable.name().toString())
@@ -933,12 +936,7 @@ public void serialize(final Appendable appendable) throws IOException {
         }
 
         public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final DocumentName workingDirectory) throws IOException {
-            DocumentBuilder builder;
-            try {
-                builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-            } catch (ParserConfigurationException e) {
-                throw new ConfigurationException("Unable to create DOM builder", e);
-            }
+            DocumentBuilder builder = StandardXmlFactory.documentBuilder();
             org.w3c.dom.Document document;
             try (InputStream stream = inputStreamSupplier.get()) {
                 document = builder.parse(stream);
@@ -997,7 +995,7 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final
      * A record that identifies a deserialized reportable.  Deserialized reportables are not executable.
      * @param name the name of the reportable.
      */
-    private record DeserializedReportable(DocumentName name) implements IReportable {
+    private record DeserializedReportable(DocumentName name) implements Reportable {
         @Override
         public void run(final RatReport report) throws RatException {
             throw new RatException("Attempt to run a deserialized reportable");
@@ -1021,5 +1019,5 @@ static IODescriptor<OutputStream> output(final String name, final DocumentName w
             DocumentName docName = workingDirectory.resolve(name);
             return new IODescriptor<OutputStream>(name, () -> new FileOutputStream(docName.asFile()));
         }
-    };
+    }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index c42ebac0e..7900d62ed 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -249,13 +249,7 @@ public Builder document(final Document document) {
             }
             @SuppressFBWarnings("XXE_DOCUMENT")
             public Builder document(final String fileName, final DocumentName workingDirectory) {
-                DocumentBuilder builder;
-                try {
-                    builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-                } catch (ParserConfigurationException e) {
-                    throw new ConfigurationException("Unable to create DOM builder", e);
-                }
-
+                DocumentBuilder builder = StandardXmlFactory.documentBuilder();
                 File inputFile = workingDirectory.resolve(fileName).asFile();
                 try (InputStream inputStream = new FileInputStream(inputFile)) {
                     this.document = builder.parse(inputStream);
@@ -277,9 +271,9 @@ public Builder statistic(final ClaimStatistic statistic) {
             public Builder statistic(final String fileName, final DocumentName workingDirectory) {
                 File sourceFile = workingDirectory.resolve(fileName).asFile();
                 try {
-                    ClaimStatistic statistic = new ClaimStatistic();
-                    statistic.serde().deserialize(() -> new FileInputStream(sourceFile));
-                    this.statistic = statistic;
+                    ClaimStatistic newStatistic = new ClaimStatistic();
+                    newStatistic.serde().deserialize(() -> new FileInputStream(sourceFile));
+                    this.statistic = newStatistic;
                     return this;
                 } catch (IOException e) {
                     throw new ConfigurationException("Unable to read file: " + sourceFile, e);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 37865a4de..6a4c41459 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -124,7 +124,7 @@ DocumentNameMatcher getLastMatcher() {
 
     DocumentName getLastMatcherBaseDir() {
         return lastMatcherBaseDir;
-    };
+    }
 
     /**
      * Reset the {@link #lastMatcher} and {@link #lastMatcherBaseDir} to start again
@@ -398,31 +398,34 @@ private void extractPaths(final MatcherSet.Builder matcherBuilder) {
     }
 
     public class Serde {
+        private final static String PATTERN = "pattern";
+        private final static String NAME = "name";
+
         public void serialize(final XmlWriter writer) throws IOException {
             writer.startElement("ExclusionProcessor");
 
             for (String pattern : excludedPatterns) {
-                writer.startElement("excludedPattern").attribute("pattern", pattern).closeElement();
+                writer.startElement("excludedPattern").attribute(PATTERN, pattern).closeElement();
             }
             for (StandardCollection obj : excludedCollections) {
-                writer.startElement("excludedCollection").attribute("name", obj.name()).closeElement();
+                writer.startElement("excludedCollection").attribute(NAME, obj.name()).closeElement();
             }
             for (DocumentNameMatcher obj : excludedPaths) {
-                writer.startElement("excludedPath").attribute("name", obj.toString()).closeElement();
+                writer.startElement("excludedPath").attribute(NAME, obj.toString()).closeElement();
             }
 
             for (String pattern : includedPatterns) {
-                writer.startElement("includedPattern").attribute("pattern", pattern).closeElement();
+                writer.startElement("includedPattern").attribute(PATTERN, pattern).closeElement();
             }
             for (StandardCollection obj : includedCollections) {
-                writer.startElement("includedCollection").attribute("name", obj.name()).closeElement();
+                writer.startElement("includedCollection").attribute(NAME, obj.name()).closeElement();
             }
             for (DocumentNameMatcher obj : includedPaths) {
-                writer.startElement("includedPath").attribute("name", obj.toString()).closeElement();
+                writer.startElement("includedPath").attribute(NAME, obj.toString()).closeElement();
             }
 
             for (StandardCollection obj : fileProcessors) {
-                writer.startElement("fileProcessor").attribute("name", obj.name()).closeElement();
+                writer.startElement("fileProcessor").attribute(NAME, obj.name()).closeElement();
             }
             writer.closeElement();
 
@@ -436,27 +439,27 @@ public void deserialize(final Node n) {
                 StandardCollection collection;
                 switch (child.getNodeName()) {
                     case "excludedPattern":
-                        excludedPatterns.add(attributes.get("pattern"));
+                        excludedPatterns.add(attributes.get(PATTERN));
                         break;
                     case "excludedCollection":
-                        collection = StandardCollection.valueOf(attributes.get("name"));
+                        collection = StandardCollection.valueOf(attributes.get(NAME));
                         excludedCollections.add(collection);
                         break;
                     case "excludedPath":
-                        excludedPaths.add(new DocumentNameMatcher(attributes.get("name"),
+                        excludedPaths.add(new DocumentNameMatcher(attributes.get(NAME),
                                 (Predicate<DocumentName>) x -> {
                                     throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
                                 }));
                         break;
                     case "includedPattern":
-                        includedPatterns.add(attributes.get("pattern"));
+                        includedPatterns.add(attributes.get(PATTERN));
                         break;
                     case "includedCollection":
-                        collection = StandardCollection.valueOf(attributes.get("name"));
+                        collection = StandardCollection.valueOf(attributes.get(NAME));
                         includedCollections.add(collection);
                         break;
                     case "includedPath":
-                        includedPaths.add(new DocumentNameMatcher(attributes.get("name"),
+                        includedPaths.add(new DocumentNameMatcher(attributes.get(NAME),
                                 (Predicate<DocumentName>) x -> {
                                     throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
                                 }));
diff --git a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
index 8da3b193e..5474501ff 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/license/LicenseSetFactory.java
@@ -321,7 +321,7 @@ public Predicate<ILicense> getApprovedLicensePredicate() {
      * @return a SortedSet of ILicense objects.
      */
     public UnmodifiableSortedSet<ILicense> getLicenses(final LicenseFilter filter) {
-        SortedSet<ILicense> result = new TreeSet<>();
+        SortedSet<ILicense> result;
         switch (filter) {
         case ALL:
             result = licenses;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java b/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
index a92ba0599..9d131ed85 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/Reportable.java
@@ -21,7 +21,7 @@
 import org.apache.rat.api.RatException;
 import org.apache.rat.document.DocumentName;
 
-public interface IReportable {
+public interface Reportable {
     /**
      * Adds the reportable to the RatReport.
      * @param report the report to add the results to.
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
index 5e3ff54fd..ea096b3a3 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
@@ -38,6 +38,7 @@
 import org.apache.rat.api.Document;
 import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.report.xml.writer.XmlWriter;
+import org.apache.rat.utils.StandardXmlFactory;
 import org.xml.sax.SAXException;
 
 /**
@@ -323,6 +324,8 @@ public String toString() {
      * Serialze and deserialze the claim Statistic.
      */
     public class Serde {
+        private static final String COUNT = "count";
+        private static final String NAME = "name";
 
         public void serialize(final Appendable appendable) throws IOException {
             try (XmlWriter writer = new XmlWriter(appendable)) {
@@ -331,8 +334,8 @@ public void serialize(final Appendable appendable) throws IOException {
                 for (Map.Entry<String, IntCounter> entry : licenseNameMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("licenseName")
-                                .attribute("count", entry.getValue().toString())
-                                .attribute("name", entry.getKey()).closeElement();
+                                .attribute(COUNT, entry.getValue().toString())
+                                .attribute(NAME, entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
@@ -340,8 +343,8 @@ public void serialize(final Appendable appendable) throws IOException {
                 for (Map.Entry<String, IntCounter> entry : licenseFamilyCategoryMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("familyCategory")
-                                .attribute("count", entry.getValue().toString())
-                                .attribute("name", entry.getKey()).closeElement();
+                                .attribute(COUNT, entry.getValue().toString())
+                                .attribute(NAME, entry.getKey()).closeElement();
                     }
                 }
                 writer.closeElement()
@@ -349,8 +352,8 @@ public void serialize(final Appendable appendable) throws IOException {
                 for (Map.Entry<Document.Type, IntCounter> entry : documentTypeMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("documentType")
-                                .attribute("count", entry.getValue().toString())
-                                .attribute("name", entry.getKey().name()).closeElement();
+                                .attribute(COUNT, entry.getValue().toString())
+                                .attribute(NAME, entry.getKey().name()).closeElement();
                     }
                 }
                 writer.closeElement()
@@ -358,8 +361,8 @@ public void serialize(final Appendable appendable) throws IOException {
                 for (Map.Entry<ClaimStatistic.Counter, IntCounter> entry : counterMap.entrySet()) {
                     if (entry.getValue().value > 0) {
                         writer.startElement("counter")
-                                .attribute("count", entry.getValue().toString())
-                                .attribute("name", entry.getKey().name()).closeElement();
+                                .attribute(COUNT, entry.getValue().toString())
+                                .attribute(NAME, entry.getKey().name()).closeElement();
                     }
                 }
                 writer.closeElement();
@@ -367,12 +370,7 @@ public void serialize(final Appendable appendable) throws IOException {
         }
 
         public void deserialize(final IOSupplier<InputStream> inputStreamSupplier) throws IOException {
-            DocumentBuilder builder;
-            try {
-                builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-            } catch (ParserConfigurationException e) {
-                throw new ConfigurationException("Unable to create DOM builder", e);
-            }
+            DocumentBuilder builder = StandardXmlFactory.documentBuilder();
             org.w3c.dom.Document document;
             try (InputStream stream = inputStreamSupplier.get()) {
                 document = builder.parse(stream);
@@ -383,24 +381,24 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier) throw
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("licenseName"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
-                incLicenseNameCount(attributes.get("name"), Integer.parseInt(attributes.get("count")));
+                incLicenseNameCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("familyCategory"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
-                incLicenseCategoryCount(attributes.get("name"), Integer.parseInt(attributes.get("count")));
+                incLicenseCategoryCount(attributes.get(NAME), Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("documentType"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
-                Document.Type type = Document.Type.valueOf(attributes.get("name"));
-                incCounter(type, Integer.parseInt(attributes.get("count")));
+                Document.Type type = Document.Type.valueOf(attributes.get(NAME));
+                incCounter(type, Integer.parseInt(attributes.get(COUNT)));
             });
 
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("counter"), node -> {
                 Map<String, String> attributes = XMLConfigurationReader.attributes(node);
-                Counter type = Counter.valueOf(attributes.get("name"));
-                setCounter(type, Integer.parseInt(attributes.get("count")));
+                Counter type = Counter.valueOf(attributes.get(NAME));
+                setCounter(type, Integer.parseInt(attributes.get(COUNT)));
             });
         }
     }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
index 50da3eccd..453f7ec60 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/FileUtils.java
@@ -22,6 +22,7 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.Collections;
 
@@ -43,7 +44,7 @@ public static void mkDir(final File dir) {
      * Deletes a file if it exists.
      * @param file the file to delete.
      */
-    public static void delete(final File file) {
+    public static void delete(final File file) throws IOException {
         if (file.exists()) {
             if (file.isDirectory()) {
                 try {
@@ -52,7 +53,7 @@ public static void delete(final File file) {
                     //
                 }
             } else {
-                boolean ignored = file.delete();
+                Files.delete(file.toPath());
             }
         }
     }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
index 1898c4e84..4a8ea03c7 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
@@ -29,7 +29,7 @@
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.document.FileDocument;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.utils.DefaultLog;
 
@@ -37,7 +37,7 @@
  * Implementation of IReportable that traverses over a resource collection
  * internally.
  */
-public class FileListWalker implements IReportable {
+public class FileListWalker implements Reportable {
     /** The source document name. */
     private final FileDocument source;
     /** The root document name. */
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
index 8df62905e..2f16013bd 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
@@ -24,18 +24,18 @@
 
 import org.apache.rat.api.RatException;
 import org.apache.rat.document.DocumentName;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
 import org.apache.rat.utils.DefaultLog;
 
 /**
  * A Reportable that walks a list of IReportables and executes the run on each.
  */
-public final class IReportableListWalker implements IReportable {
+public final class ReportableListWalker implements Reportable {
     /** The document name for this walker. */
     private final DocumentName documentName;
     /** The list of reportables for this walker. */
-    private final List<IReportable> reportables;
+    private final List<Reportable> reportables;
 
     /**
      * Create a builder for the list walker.
@@ -50,14 +50,14 @@ public static Builder builder(final DocumentName name) {
      * Construct the builder.
      * @param builder for the reportable.
      */
-    private IReportableListWalker(final Builder builder) {
+    private ReportableListWalker(final Builder builder) {
         this.documentName = builder.documentName;
         this.reportables = builder.reportables;
     }
 
     @Override
     public void run(final RatReport report) {
-        for (IReportable reportable : reportables) {
+        for (Reportable reportable : reportables) {
             try {
                 reportable.run(report);
             } catch (RatException e) {
@@ -78,7 +78,7 @@ public static final class Builder {
         /** The document name for the walker. */
         private final DocumentName documentName;
         /** The list of IReportable objects to execute. */
-        private List<IReportable> reportables = new ArrayList<>();
+        private List<Reportable> reportables = new ArrayList<>();
 
         /**
          * Constructs the builder.
@@ -94,7 +94,7 @@ private Builder(final DocumentName name) {
          * @param reportable the reportable to run.
          * @return this.
          */
-        public Builder addReportable(final IReportable reportable) {
+        public Builder addReportable(final Reportable reportable) {
             this.reportables.add(reportable);
             return this;
         }
@@ -104,11 +104,11 @@ public Builder addReportable(final IReportable reportable) {
          * @return the reportable.
          * @throws RatException on error.
          */
-        public IReportable build() throws RatException {
+        public Reportable build() throws RatException {
             if (reportables == null) {
                 throw new RatException("Builder may only be used once");
             }
-            IReportable result = new IReportableListWalker(this);
+            Reportable result = new ReportableListWalker(this);
             this.reportables = null;
             return result;
         }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
index f0e6d7bd4..a6df1e25c 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/Walker.java
@@ -21,12 +21,12 @@
 
 import org.apache.rat.api.Document;
 import org.apache.rat.document.DocumentName;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 
 /**
  * Abstract walker.
  */
-public abstract class Walker implements IReportable {
+public abstract class Walker implements Reportable {
 
     /** The document this walker is walking */
     private final Document document;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
index f18ee2ab9..0da85fb5b 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
@@ -20,6 +20,7 @@
 
 import org.apache.commons.cli.Option;
 import org.apache.commons.cli.ParseException;
+import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.ui.UIOption;
 import org.apache.rat.ui.UIOptionCollection;
@@ -42,7 +43,7 @@ class OptionCollectionParserTest {
     private final OptionCollectionParser underTest = new OptionCollectionParser(optionCollection);
 
     @Test
-    void parseCommands() throws IOException, ParseException {
+    void parseCommands() throws RatException {
         String[] args = {"arg1", "arg2"};
         ArgumentContext ctxt = underTest.parseCommands(testPath.toFile(), args);
         assertThat(ctxt.getCommandLine().getArgList()).containsExactly(args);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
index 72871edf6..9b2592acf 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionTest.java
@@ -30,15 +30,14 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.TreeMap;
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
+
 import org.apache.commons.cli.Option;
 import org.apache.commons.cli.ParseException;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.license.LicenseSetFactory;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.test.AbstractConfigurationOptionsProvider;
 import org.apache.rat.test.utils.OptionFormatter;
 import org.apache.rat.testhelpers.TestingLog;
@@ -234,7 +233,7 @@ public void getReportableTest(String fName) throws IOException {
         DocumentName.FSInfo fsInfo = new DocumentName.FSInfo(testPath.getFileSystem());
         String expected = fsInfo.normalize(base.getAbsolutePath());
         ReportConfiguration config = OptionCollection.parseCommands(testPath.toFile(), new String[]{fName}, o -> fail("Help called"), false);
-        IReportable reportable = OptionCollection.getReportable(base, config);
+        Reportable reportable = OptionCollection.getReportable(base, config);
         assertThat(reportable).as(() -> format("'%s' returned null", fName)).isNotNull();
         assertThat(reportable.name().getName()).isEqualTo(expected);
     }
@@ -251,7 +250,7 @@ void getReportable() throws IOException {
         reportConfiguration.addExcludedPatterns(List.of(dir2.getName()));
         assertThat(OptionCollection.getReportable(dir2, reportConfiguration)).isNull();
 
-        IReportable reportable = OptionCollection.getReportable(dir1, new ReportConfiguration());
+        Reportable reportable = OptionCollection.getReportable(dir1, new ReportConfiguration());
         assertThat(reportable).isInstanceOf(DirectoryWalker.class);
 
         File file1 = new File(dir1, "file1");
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
index f29c622ea..68c2c30af 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
@@ -37,22 +37,29 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.SortedSet;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import org.apache.commons.io.filefilter.DirectoryFileFilter;
+import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.io.output.CloseShieldOutputStream;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.rat.analysis.IHeaderMatcher;
+import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.config.AddLicenseHeaders;
 import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.configuration.XMLConfigurationReaderTest;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.license.ILicense;
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.testhelpers.TestingLog;
 import org.apache.rat.testhelpers.TestingLicense;
 import org.apache.rat.testhelpers.TestingMatcher;
@@ -65,6 +72,12 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.mockito.Mockito;
+import org.w3c.dom.Node;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 
 public class ReportConfigurationTest {
 
@@ -470,10 +483,10 @@ public void outputTest() throws IOException {
     @Test
     public void reportableTest() {
         assertThat(underTest.hasSource()).isFalse();
-        IReportable reportable = mock(IReportable.class);
+        Reportable reportable = mock(Reportable.class);
         underTest.addSource(reportable);
         assertThat(underTest.hasSource()).isTrue();
-        assertThatThrownBy(() -> underTest.addSource((IReportable)null)).isExactlyInstanceOf(ConfigurationException.class)
+        assertThatThrownBy(() -> underTest.addSource((Reportable)null)).isExactlyInstanceOf(ConfigurationException.class)
                 .hasMessageContaining("Reportable may not be null.");
     }
 
@@ -530,7 +543,7 @@ public void testValidate() {
 
 
             msg = "At least one license must be defined";
-        underTest.addSource(mock(IReportable.class));
+        underTest.addSource(mock(Reportable.class));
 
             assertThatThrownBy(underTest::validate).isExactlyInstanceOf(ConfigurationException.class)
                 .hasMessageContaining(msg);
@@ -751,4 +764,127 @@ public void close() {
             ++closeCount;
         }
     }
+
+//    @Test
+//    void serdeTest() {
+//        ReportConfiguration undertest = new ReportConfiguration();
+//        underTest.setCopyrightMessage("the copyright message");
+//
+//
+//    }
+//
+//    /*
+//        public class Serde {
+//        /**
+//         * Writes the configuration as an XML document to the appendable.
+//         *
+//         * @param appendable the Appendable to write to.
+//         * @throws IOException on error.
+//         */
+//    public void serialize(final Appendable appendable) throws IOException {
+//        try (XmlWriter writer = new XmlWriter(appendable)) {
+//            writer.startElement("ReportConfiguration")
+//                    .attribute("addingLicenses", Boolean.toString(addingLicenses))
+//                    .attribute("addingLicensesForced", Boolean.toString(addingLicensesForced))
+//                    .attribute("listFamilies", listFamilies.name())
+//                    .attribute("listLicenses", listLicenses.name())
+//                    .attribute("dryRun", Boolean.toString(dryRun))
+//                    .attribute("archiveProcessing", getArchiveProcessing().name())
+//                    .attribute("standardProcessing", getStandardProcessing().name())
+//                    .attribute("stylesheet", styleSheet.name())
+//                    .attribute("output", out.name());
+//            if (StringUtils.isNotEmpty(copyrightMessage)) {
+//                writer.startElement("copyrightMessage").content(copyrightMessage).closeElement();
+//            }
+//            writer.startElement("sources");
+//            for (File f : sources) {
+//                writer.startElement("source").attribute("name", f.getName()).closeElement();
+//            }
+//            writer.closeElement("sources").startElement("reportables");
+//            for (Reportable reportable : reportables) {
+//                writer.startElement("reportable")
+//                        .attribute("baseName", reportable.name().getBaseName())
+//                        .attribute("name", reportable.name().toString())
+//                        .attribute("class", reportable.getClass().getName()).closeElement();
+//            }
+//            writer.closeElement();
+//
+//            exclusionProcessor.serde().serialize(writer);
+//
+//            writer.startElement("claimValidator");
+//            for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+//                writer.startElement("claimCounter")
+//                        .attribute("name", counter.name()).attribute("min", Integer.toString(claimValidator.getMin(counter)))
+//                        .attribute("max", Integer.toString(claimValidator.getMax(counter))).closeElement();
+//            }
+//            writer.closeElement();
+//        } catch (IOException e) {
+//            throw e;
+//        } catch (Exception e) {
+//            throw new IOException(e);
+//        }
+//    }
+//
+//    public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final DocumentName workingDirectory) throws IOException {
+//        DocumentBuilder builder;
+//        try {
+//            builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+//        } catch (ParserConfigurationException e) {
+//            throw new ConfigurationException("Unable to create DOM builder", e);
+//        }
+//        org.w3c.dom.Document document;
+//        try (InputStream stream = inputStreamSupplier.get()) {
+//            document = builder.parse(stream);
+//        } catch (SAXException e) {
+//            throw new IOException("Unable to read input", e);
+//        }
+//        Node node = document.getDocumentElement();
+//        if (!node.getNodeName().equals("ReportConfiguration")) {
+//            throw new IOException("Invalid ReportConfiguration");
+//        }
+//        Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+//        addingLicensesForced = Boolean.parseBoolean(attributes.get("addingLicensesForced"));
+//        listFamilies = LicenseFilter.valueOf(attributes.get("listFamilies"));
+//        listLicenses = LicenseFilter.valueOf(attributes.get("listLicenses"));
+//        dryRun = Boolean.parseBoolean(attributes.get("dryRun"));
+//        archiveProcessing = ReportConfiguration.Processing.valueOf(attributes.get("archiveProcessing"));
+//        standardProcessing = ReportConfiguration.Processing.valueOf(attributes.get("standardProcessing"));
+//        String styleName = attributes.get("stylesheet");
+//        if (styleName != null) {
+//            styleSheet = StyleSheets.getStyleSheet(styleName, workingDirectory);
+//        }
+//        String outputName = attributes.get("output");
+//        if (outputName != null) {
+//            if (outputName.equals(ReportConfiguration.SYSTEM_OUT.name())) {
+//                out = ReportConfiguration.SYSTEM_OUT;
+//            } else {
+//                out = ReportConfiguration.IODescriptor.output(outputName, workingDirectory);
+//            }
+//        }
+//
+//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("source"), lNode -> {
+//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+//            addSource(new File(nAttributes.get("name")));
+//        });
+//
+//        // Deserialize the reportables.
+//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("reportable"), lNode -> {
+//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+//            DocumentName documentName = DocumentName.builder().setBaseName(nAttributes.get("baseName"))
+//                    .setName(nAttributes.get("name")).build();
+//            addSource(new ReportConfiguration.DeserializedReportable(documentName));
+////        });
+//
+//        exclusionProcessor.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
+//
+//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("claimCounter"), lNode -> {
+//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
+//            ClaimStatistic.Counter counter = ClaimStatistic.Counter.valueOf(nAttributes.get("name"));
+//            claimValidator.setMin(counter, Integer.parseInt(nAttributes.get("min")));
+//            claimValidator.setMax(counter, Integer.parseInt(nAttributes.get("max")));
+//        });
+//    }
+//}
+//
+//     */
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index 0d0e99425..be39b3608 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -392,7 +392,7 @@ protected void inputExcludeSizeTest() {
             Reporter reporter = new Reporter(config);
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
 
             // filter out source
             config = generateConfig(ImmutablePair.of(option, args));
@@ -483,7 +483,7 @@ protected void inputExcludeParsedScmTest() {
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(11);
             // .gitignore is ignored by default as it is hidden but not counted
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
 
             config = generateConfig(ImmutablePair.of(option, args));
             reporter = new Reporter(config);
@@ -610,13 +610,13 @@ protected void inputSourceTest() {
             Reporter reporter = new Reporter(config);
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(3);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
 
             config = generateConfig(ImmutablePair.of(option, new String[]{inputFile.getAbsolutePath()}));
             reporter = new Reporter(config);
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.IGNORED)).isZero();
         });
     }
 
@@ -641,7 +641,7 @@ private void execLicenseFamiliesApprovedTest(final Option option, final String[]
             Reporter.Output output = reporter.execute();
 
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             config = addCatzLicense(generateConfig(arg1));
@@ -649,7 +649,7 @@ private void execLicenseFamiliesApprovedTest(final Option option, final String[]
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
         });
     }
 
@@ -681,13 +681,13 @@ private void execLicenseFamiliesDeniedTest(final Option option, final String[] a
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
         });
     }
@@ -729,7 +729,7 @@ private void configTest(final Option option) {
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
 
             Pair<Option, String[]> arg2 = ImmutablePair.of(Arg.CONFIGURATION_NO_DEFAULTS.find("configuration-no-defaults"), null);
 
@@ -775,7 +775,7 @@ protected void execLicensesApprovedTest(final Option option, String[] args) {
             output  = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(2);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(2);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
         });
     }
 
@@ -811,7 +811,7 @@ protected void scanHiddenDirectoriesTest() {
             Reporter.Output output = reporter.execute();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
 
             config = generateConfig(arg1);
             reporter = new Reporter(config);
@@ -836,7 +836,7 @@ private void outTest(final Option option) {
             output.format(config);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isZero();
 
             String actualText = TextUtils.readFile(outFile);
             TextUtils.assertContainsExactly(1, "Apache License 2.0: 1 ", actualText);
@@ -876,7 +876,7 @@ private void styleSheetTest(final Option option) {
                 Reporter.Output output  = reporter.execute();
                 output.format(config);
                 assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-                assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+                assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
                 assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
                 String actualText = baos.toString(StandardCharsets.UTF_8);
@@ -910,7 +910,7 @@ private void styleSheetTest(final Option option) {
             Reporter.Output output  = reporter.execute();
             output.format(config);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             String actualText = baos.toString(StandardCharsets.UTF_8);
@@ -953,7 +953,7 @@ protected void xmlTest() {
             Reporter.Output output  = reporter.execute();
             output.format(config);
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.STANDARDS)).isEqualTo(1);
-            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isEqualTo(0);
+            assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.APPROVED)).isZero();
             assertThat(output.getStatistic().getCounter(ClaimStatistic.Counter.UNAPPROVED)).isEqualTo(1);
 
             String actualText = baos.toString(StandardCharsets.UTF_8);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 9aab15aad..6e7e7f2db 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -94,10 +94,6 @@ public class ReporterTest {
      * always work.
      */
     private static Path tempPath;
-    /**
-     * The TestInfo for the current test.
-     */
-    private TestInfo testInfo;
 
     /**
      * The directory for the test.
@@ -128,7 +124,6 @@ static void cleanup() throws IOException {
 
     @BeforeEach
     void setUpTest(TestInfo testInfo) {
-        this.testInfo = testInfo;
         Optional<Method> testMethod = testInfo.getTestMethod();
         this.testPath = tempPath.resolve(testMethod.isPresent() ?
                         testMethod.get().getName() :
@@ -148,7 +143,6 @@ void setUpTest(TestInfo testInfo) {
     @Test
     void testExecute() throws RatException, ParseException, IOException {
         File output = testPath.resolve("output.xml").toFile();
-        BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
         ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
         ClaimStatistic statistic = new Reporter(ctxt.getConfiguration()).execute().getStatistic();
 
@@ -213,7 +207,6 @@ void testOutputOption() throws Exception {
     @Test
     void testDefaultOutput() throws Exception {
         File output = testPath.resolve("captured.txt").toFile();
-        BaseOptionCollection optionCollection = BaseOptionCollection.builder().build();
 
         PrintStream origin = System.out;
         try (PrintStream out = new PrintStream(output)) {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
index 9ed0df624..19c2d62b4 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
@@ -62,7 +62,6 @@ public void setOut(File file) {
         Path workingPath = localFile.getAbsoluteFile().toPath();
         String expected = fsInfo.normalize(workingPath.resolve("./" + fileName).toString());
 
-        CommandLine commandLine = createCommandLine(new String[]{"--output-file", fileName});
         OutputFileConfig configuration = new OutputFileConfig();
         ArgumentContext ctxt = new ArgumentContext(localFile, configuration, CLIOptionCollection.INSTANCE.getOptions(), new String[]{"--output-file", fileName});
         Arg.processArgs(ctxt, CLIOptionCollection.INSTANCE);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
index 10b3e54a6..71e9e7a1a 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
@@ -31,7 +31,6 @@
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.testhelpers.TextUtils;
-import org.apache.rat.testhelpers.XmlUtils;
 import org.apache.rat.utils.StandardXmlFactory;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -406,7 +405,7 @@ static List<ExclusionProcessor> serdeTestData() {
     }
 
     @Test
-    void reportExclusionsTest() throws IOException, SAXException {
+    void reportExclusionsTest() throws IOException {
         ExclusionProcessor underTest = new ExclusionProcessor()
                 .addExcludedPatterns(List.of("pattern/**", "pattern2/**"))
                 .addExcludedCollection(StandardCollection.BAZAAR)
@@ -422,17 +421,17 @@ void reportExclusionsTest() throws IOException, SAXException {
         underTest.reportExclusions(writer);
         String actual = writer.toString();
 
-        TextUtils.assertPatternInTarget("Excluding patterns:[^$]+\\Qpattern/**\\E", actual);
-        TextUtils.assertPatternInTarget("Excluding patterns:[^$]+\\Qpattern2/**\\E", actual);
-        TextUtils.assertPatternInTarget("Including patterns:[^$]+\\Q**/pattern3\\E", actual);
-        TextUtils.assertPatternInTarget("Including patterns:[^$]+\\Q**/pattern4\\E", actual);
-        assertThat(actual).contains("Excluding " + StandardCollection.BAZAAR + " collection.");
-        assertThat(actual).contains("Excluding " + StandardCollection.MISC + " collection.");
-        assertThat(actual).contains("Including " + StandardCollection.ARCH + " collection.");
-        assertThat(actual).contains("Including " + StandardCollection.BITKEEPER + " collection.");
-        assertThat(actual).contains("Processing exclude file from " + StandardCollection.HIDDEN_FILE);
-        assertThat(actual).contains("Excluding " + DocumentNameMatcher.MATCHES_ALL + ".");
-        assertThat(actual).contains("Including " + DocumentNameMatcher.MATCHES_NONE + ".");
+        assertThat(actual).containsPattern("Excluding patterns:[^$]+\\Qpattern/**\\E")
+                .containsPattern("Excluding patterns:[^$]+\\Qpattern2/**\\E")
+                .containsPattern("Including patterns:[^$]+\\Q**/pattern3\\E")
+                .containsPattern("Including patterns:[^$]+\\Q**/pattern4\\E")
+                .contains("Excluding " + StandardCollection.BAZAAR + " collection.")
+                .contains("Excluding " + StandardCollection.MISC + " collection.")
+                .contains("Including " + StandardCollection.ARCH + " collection.")
+                .contains("Including " + StandardCollection.BITKEEPER + " collection.")
+                .contains("Processing exclude file from " + StandardCollection.HIDDEN_FILE)
+                .contains("Excluding " + DocumentNameMatcher.MATCHES_ALL + ".")
+                .contains("Including " + DocumentNameMatcher.MATCHES_NONE + ".");
     }
 
     @Test
diff --git a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
index 5d2caa1ed..10c9759fb 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/configuration/XMLConfigurationReaderTest.java
@@ -68,7 +68,7 @@ void approvedLicenseIdTest() throws URISyntaxException {
     }
 
     @Test
-    public void LicensesTest() throws URISyntaxException {
+    void LicensesTest() throws URISyntaxException {
         XMLConfigurationReader reader = new XMLConfigurationReader();
         URL url = XMLConfigurationReaderTest.class.getResource("/org/apache/rat/default.xml");
         reader.read(url.toURI());
diff --git a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
index 246729206..5bee29740 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/test/AbstractConfigurationOptionsProvider.java
@@ -19,6 +19,7 @@
 package org.apache.rat.test;
 
 import java.io.FileWriter;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.FileSystems;
 import java.nio.file.Path;
 import org.apache.commons.cli.Option;
@@ -822,12 +823,12 @@ private void styleSheetTest(final Option option) {
                 DocumentName expectedName = base.resolve(sheet);
                 try (InputStream expected = StyleSheets.getStyleSheet(sheet, base).ioSupplier().get();
                      InputStream actual = config.getStyleSheet().get()) {
-                    String expectedStr =  IOUtils.toString(expected);
-                    String actualStr =  IOUtils.toString(actual);
-                    assertThat(actualStr).isEqualTo(expectedStr).as(() -> String.format("'%s' does not match '%s': %s != %s",
+                    String expectedStr =  IOUtils.toString(expected, StandardCharsets.UTF_8);
+                    String actualStr =  IOUtils.toString(actual, StandardCharsets.UTF_8);
+                    assertThat(actualStr).as(() -> String.format("'%s' does not match '%s': %s != %s",
                             config.getStyleSheetDescriptor().name(),
                             expectedName.getName(),
-                            actualStr, expectedStr));
+                            actualStr, expectedStr)).isEqualTo(expectedStr);
                 }
             }
         });
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
index 18b507103..3500c44d0 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/BaseOptionCollection.java
@@ -18,7 +18,6 @@
  */
 package org.apache.rat.testhelpers;
 
-import org.apache.commons.cli.Option;
 import org.apache.rat.ui.UIOptionCollection;
 
 public final class BaseOptionCollection extends UIOptionCollection<BaseOption> {
@@ -35,6 +34,7 @@ private Builder() {
             super(BaseOption::new);
         }
 
+        @Override
         public BaseOptionCollection build() {
             return new BaseOptionCollection(this);
         }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
index e90a30b9c..72931b49e 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/TextUtils.java
@@ -40,7 +40,9 @@ public class TextUtils {
      *
      * @param pattern the pattern to match.
      * @param target  the string to match.
+     * @deprecated use  assertThat(target).containsPattern(pattern)
      */
+    @Deprecated
     public static void assertPatternInTarget(String pattern, String target) {
         assertThat(isMatching(pattern, target)).as(() -> format("Target does not match string: %s%n%s", pattern, target))
                         .isTrue();
@@ -51,7 +53,9 @@ public static void assertPatternInTarget(String pattern, String target) {
      *
      * @param pattern the pattern to match.
      * @param target  the string to match.
+     * @deprecated use assertThat(target).dosNotContainPattern(pattern)
      */
+    @Deprecated
     public static void assertPatternNotInTarget(String pattern, String target) {
         assertThat(isMatching(pattern, target)).as(() -> format("Target matches the pattern: %s%n%s", pattern, target))
                 .isFalse();
@@ -63,7 +67,9 @@ public static void assertPatternNotInTarget(String pattern, String target) {
      * @param pattern the pattern to match.
      * @param target  the string to match.
      * @return {@code true} if a regular expression pattern is in a string
+     * @deprecated use assertThat(target).matches(pattern)
      */
+    @Deprecated
     public static boolean isMatching(final String pattern, final String target) {
         return Pattern.compile(pattern, Pattern.MULTILINE).matcher(target).find();
     }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
index 6bc5682f8..92c8feca5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
@@ -35,6 +35,7 @@
 import org.apache.rat.ui.UIOptionCollection;
 import org.apache.rat.ui.ArgumentTracker;
 import org.apache.rat.utils.DefaultLog;
+import org.apache.rat.utils.Log;
 
 /**
  * Generates a list of TestData for executing the Report.
@@ -47,7 +48,8 @@ public abstract class AbstractTestDataProvider {
     static final String[] EXCLUDE_ARGS = {"*.foo", "%regex[[A-Z]\\.bar]", "justbaz"};
     /** the list of include args */
     static final String[] INCLUDE_ARGS = {"B.bar", "justbaz"};
-    public final ImmutableList<ImmutablePair<Option, String[]>> NO_OPTIONS = ImmutableList.of(ImmutablePair.nullPair());
+    // Sonar suggests List of but we need an Immutable list.
+    public static final ImmutableList<ImmutablePair<Option, String[]>> NO_OPTIONS = ImmutableList.of(ImmutablePair.nullPair()); // NOSONAR
 
     /**
      * Generates a map of TestData indexed by the testName
@@ -110,6 +112,8 @@ public final Set<TestData> getOptionTests(final UIOptionCollection<?> optionColl
                     case OUTPUT_LICENSES -> options.forEach(opt -> outputLicensesTest(result, opt));
                     case OUTPUT_STANDARD -> options.forEach(opt -> outputStandardTest(result, opt));
                     case OUTPUT_STYLE -> options.forEach(opt -> outputStyleTest(result, opt));
+                    case DIR -> {/* do nothing */}
+                    default -> throw new IllegalStateException("Unrecognized Arg: " + arg.name());
                 }
             }
         }
@@ -120,9 +124,9 @@ public final Set<TestData> getOptionTests(final UIOptionCollection<?> optionColl
     private void validate(Set<TestData> result) {
         Set<Option> options = new HashSet<>(Arg.getOptions().getOptions());
         result.forEach(testData -> options.remove(testData.getOption()));
-        // TODO fix this once deprecated options are removed
+        // TODO fix this once deprecated options are removed  NOSONAR
         options.forEach(opt -> DefaultLog.getInstance().warn("Option " + ArgumentTracker.extractKey(opt) + " was not tested."));
-        //assertThat(options).describedAs("All options are not accounted for.").isEmpty();
+        //assertThat(options).describedAs("All options are not accounted for.").isEmpty(); // NOSONAR
     }
 
     protected abstract void inputExcludeFileTest(final Set<TestData> result, final Option option);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
index 88f78bc35..2f4375791 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/ReportTestDataProvider.java
@@ -66,6 +66,7 @@
 import static org.apache.rat.testhelpers.data.DataUtils.NO_SETUP;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Fail.fail;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 /**
  * Generates a list of TestData for executing the Report.
@@ -134,7 +135,6 @@ private List<TestData> execExcludeTest(final Option option, final Supplier<Strin
                 setup,
                 validatorData -> {
                     DefaultLog.getInstance().warn("validating execExcludeTest for " + validatorData.getBaseDir());
-                    ClaimStatistic claimStatistic = validatorData.getStatistic();
                     assertCounter(validatorData, ClaimStatistic.Counter.STANDARDS, standard.length);
                     assertCounter(validatorData, ClaimStatistic.Counter.IGNORED, ignored.length);
                     for (String fileName : ignored) {
@@ -574,7 +574,7 @@ protected void licensesDeniedTest(final Set<TestData> result, final Option optio
 
     protected void licensesDeniedFileTest(final Set<TestData> result, final Option option) {
         result.addAll(execLicensesDeniedTest(option, new String[]{"licensesDenied.txt"},
-                (basePath) -> writeFile(basePath.toFile(), "licensesDenied.txt", Collections.singletonList("ILLUMOS"))));
+                basePath -> writeFile(basePath.toFile(), "licensesDenied.txt", Collections.singletonList("ILLUMOS"))));
     }
 
     private List<TestData> execLicenseFamiliesApprovedTest(final Option option, final String[] args, Consumer<Path> extraSetup) {
@@ -1088,8 +1088,8 @@ protected void outputFileTest(final Set<TestData> result, final Option option) {
 
                     try {
                         String actualText = TextUtils.readFile(outFile);
-                        TextUtils.assertPatternInTarget("Apache License 2.0: \\d", actualText);
-                        TextUtils.assertPatternInTarget("STANDARD:\\s+\\d", actualText);
+                        assertThat(actualText).containsPattern("Apache License 2.0: \\d")
+                                .containsPattern("STANDARD:\\s+\\d");
                     } catch (IOException e) {
                         throw new RuntimeException(e);
                     }
@@ -1248,20 +1248,20 @@ protected void outputStyleTest(final Set<TestData> result, final Option option)
                         DefaultLog.getInstance().warn("outputStyleTest setup for " + basePath);
                         DocumentName name = DocumentName.builder().setName("fileStyleSheet.xslt")
                                 .setBaseName(basePath.toString()).build();
-                        try (FileWriter fileWriter = new FileWriter(name.asFile(), StandardCharsets.UTF_8);
-                             XmlWriter writer = new XmlWriter(fileWriter)) {
-                            writer.startDocument()
-                                    .comment(DataUtils.ASF_TEXT)
-                                    .startElement("xsl:stylesheet")
-                                    .attribute("version", "1.0")
-                                    .attribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform")
-                                    .startElement("xsl:template")
-                                    .attribute("match", "@*|node()")
-                                    .content("Hello World")
-                                    .closeDocument();
-                        } catch (IOException e) {
-                            fail(e.getMessage(), e);
-                        }
+                        assertDoesNotThrow(() -> {
+                            try (FileWriter fileWriter = new FileWriter(name.asFile(), StandardCharsets.UTF_8);
+                                 XmlWriter writer = new XmlWriter(fileWriter)) {
+                                writer.startDocument()
+                                        .comment(DataUtils.ASF_TEXT)
+                                        .startElement("xsl:stylesheet")
+                                        .attribute("version", "1.0")
+                                        .attribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform")
+                                        .startElement("xsl:template")
+                                        .attribute("match", "@*|node()")
+                                        .content("Hello World")
+                                        .closeDocument();
+                            }
+                        });
                     },
 
                     validatorData -> {
diff --git a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
index 1cc128b87..d400b53cc 100644
--- a/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
+++ b/apache-rat-plugin/src/main/java/org/apache/rat/mp/RatCheckMojo.java
@@ -159,9 +159,6 @@ public void setCopyrightMessage(final String copyrightMessage) {
     @Parameter(property = "rat.consoleOutput", defaultValue = "true")
     private boolean consoleOutput;
 
-    /** The reporter that this mojo uses */
-    private Reporter reporter;
-
     @Override
     protected ReportConfiguration getConfiguration() throws MojoExecutionException {
         ReportConfiguration result = super.getConfiguration();
@@ -209,8 +206,7 @@ public void execute() throws MojoExecutionException, MojoFailureException {
                 config.reportExclusions(logWriter);
             }
             try {
-                this.reporter = new Reporter(config);
-                Reporter.Output output = reporter.execute();
+                Reporter.Output output = new Reporter(config).execute();
                 if (verbose) {
                     output.writeSummary(logWriter);
                 }
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
index efb28ab30..79f0aa985 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/Report.java
@@ -411,7 +411,7 @@ public ReportConfiguration getConfiguration() {
             boolean helpLicenses = !getValues(Arg.HELP_LICENSES).isEmpty();
             removeKey(Arg.HELP_LICENSES);
             File antFileDir = new File(getProject().getProperty("ant.file")).getParentFile();
-            DocumentName name = DocumentName.builder(antFileDir).build();;
+            DocumentName name = DocumentName.builder(antFileDir).build();
             final ReportConfiguration configuration = OptionCollection.parseCommands(antFileDir, args().toArray(new String[0]),
                     o -> DefaultLog.getInstance().warn("Help option not supported"),
                     true);
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
index b9ddddfd0..c4adc8d88 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
@@ -22,7 +22,7 @@
 import org.apache.rat.api.RatException;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.FileDocument;
-import org.apache.rat.report.IReportable;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
 import org.apache.tools.ant.types.Resource;
 import org.apache.tools.ant.types.ResourceCollection;
@@ -32,7 +32,7 @@
  * Implementation of IReportable that traverses over a resource collection
  * internally.
  */
-class ResourceCollectionContainer implements IReportable {
+class ResourceCollectionContainer implements Reportable {
     /** The resources as collected by Ant */
     private final ResourceCollection resources;
     /** The report configuration being used for the report */

From cfa48bb5539c0ecd32cab797990f402d4d5a9bf8 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Fri, 26 Jun 2026 09:20:27 +0100
Subject: [PATCH 33/36] fixed checkstyle issues

---
 .../org/apache/rat/ReportConfiguration.java   |  4 +---
 .../main/java/org/apache/rat/Reporter.java    |  2 --
 .../config/exclusion/ExclusionProcessor.java  | 24 +++++++++++++++----
 .../rat/report/claim/ClaimStatistic.java      | 15 +++++++++---
 .../org/apache/rat/walker/FileListWalker.java |  2 +-
 .../rat/walker/ReportableListWalker.java      |  2 +-
 .../anttasks/ResourceCollectionContainer.java |  2 +-
 7 files changed, 35 insertions(+), 16 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index 97fb3b049..3f3825f2e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -39,8 +39,6 @@
 import java.util.SortedSet;
 
 import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 
 import org.apache.commons.collections4.set.UnmodifiableSortedSet;
 import org.apache.commons.io.function.IOSupplier;
@@ -62,8 +60,8 @@
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
-import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.utils.DefaultLog;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index 7900d62ed..f4aae5410 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -29,8 +29,6 @@
 import java.nio.charset.StandardCharsets;
 
 import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 6a4c41459..83c962530 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -397,10 +397,20 @@ private void extractPaths(final MatcherSet.Builder matcherBuilder) {
         }
     }
 
+    /**
+     * Serializes and deserializes the ExclusionProcessor to XML document
+     */
     public class Serde {
-        private final static String PATTERN = "pattern";
-        private final static String NAME = "name";
-
+        /** The pattern attribute name */
+        private static final String PATTERN = "pattern";
+        /** THe name attribute name */
+        private static final String NAME = "name";
+
+        /**
+         * Serialize the ExclusionProcessor to XML writer.
+         * @param writer the writer to serialize to.
+         * @throws IOException on Error
+         */
         public void serialize(final XmlWriter writer) throws IOException {
             writer.startElement("ExclusionProcessor");
 
@@ -431,8 +441,12 @@ public void serialize(final XmlWriter writer) throws IOException {
 
         }
 
-        public void deserialize(final Node n) {
-            final NodeList children = n.getChildNodes();
+        /**
+         * Deserialize from XML Document node to ExclusionProcessor
+         * @param xmlNode the node to deserialize from.
+         */
+        public void deserialize(final Node xmlNode) {
+            final NodeList children = xmlNode.getChildNodes();
             for (int i = 0; i < children.getLength(); i++) {
                 Node child = children.item(i);
                 Map<String, String> attributes = XMLConfigurationReader.attributes(child);
diff --git a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
index ea096b3a3..f2aac3a88 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/report/claim/ClaimStatistic.java
@@ -29,12 +29,9 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 
 import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.lang3.StringUtils;
-import org.apache.rat.ConfigurationException;
 import org.apache.rat.api.Document;
 import org.apache.rat.configuration.XMLConfigurationReader;
 import org.apache.rat.report.xml.writer.XmlWriter;
@@ -324,9 +321,16 @@ public String toString() {
      * Serialze and deserialze the claim Statistic.
      */
     public class Serde {
+        /** The count attribute string */
         private static final String COUNT = "count";
+        /** the name attribute string */
         private static final String NAME = "name";
 
+        /**
+         * Serializes the claim statistic into an appendable.
+         * @param appendable the appendable to write to
+         * @throws IOException on error.
+         */
         public void serialize(final Appendable appendable) throws IOException {
             try (XmlWriter writer = new XmlWriter(appendable)) {
                 writer.startDocument().startElement("ClaimStatistic")
@@ -369,6 +373,11 @@ public void serialize(final Appendable appendable) throws IOException {
             }
         }
 
+        /**
+         * Deserializes a ClaimStatistic from an input stream.
+         * @param inputStreamSupplier the supplier of the input stream to deserialize from.
+         * @throws IOException on error.
+         */
         public void deserialize(final IOSupplier<InputStream> inputStreamSupplier) throws IOException {
             DocumentBuilder builder = StandardXmlFactory.documentBuilder();
             org.w3c.dom.Document document;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
index 4a8ea03c7..eb62c0f29 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/FileListWalker.java
@@ -29,8 +29,8 @@
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.document.FileDocument;
-import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.utils.DefaultLog;
 
 /**
diff --git a/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
index 2f16013bd..b4afad47e 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/walker/ReportableListWalker.java
@@ -24,8 +24,8 @@
 
 import org.apache.rat.api.RatException;
 import org.apache.rat.document.DocumentName;
-import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
 import org.apache.rat.utils.DefaultLog;
 
 /**
diff --git a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
index c4adc8d88..baab5e9ac 100644
--- a/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
+++ b/apache-rat-tasks/src/main/java/org/apache/rat/anttasks/ResourceCollectionContainer.java
@@ -22,8 +22,8 @@
 import org.apache.rat.api.RatException;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.FileDocument;
-import org.apache.rat.report.Reportable;
 import org.apache.rat.report.RatReport;
+import org.apache.rat.report.Reportable;
 import org.apache.tools.ant.types.Resource;
 import org.apache.tools.ant.types.ResourceCollection;
 import org.apache.tools.ant.types.resources.FileResource;

From f8e968c225faa8a2aaaca3bb803c3bb2c97d5577 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sat, 27 Jun 2026 08:55:22 +0100
Subject: [PATCH 34/36] fixes for SonarQube results

---
 apache-rat-core/pom.xml                       |   5 +
 .../it/java/org/apache/rat/ReportTest.java    |  13 +-
 .../apache/rat/ConfigurationException.java    |   4 +-
 .../main/java/org/apache/rat/Defaults.java    |   3 +-
 .../apache/rat/ImplementationException.java   |   4 +-
 .../apache/rat/OptionCollectionParser.java    |  17 +-
 .../org/apache/rat/ReportConfiguration.java   |  38 ++-
 .../main/java/org/apache/rat/Reporter.java    |   4 +-
 .../config/exclusion/ExclusionProcessor.java  |   5 +-
 .../apache/rat/utils/StandardXmlFactory.java  |  55 ++++-
 .../rat/OptionCollectionParserTest.java       |   2 -
 .../test/java/org/apache/rat/OutputTest.java  | 167 ++++++++++++++
 .../apache/rat/ReportConfigurationTest.java   | 216 +++++++-----------
 .../apache/rat/ReporterOptionsProvider.java   |   4 -
 .../java/org/apache/rat/ReporterTest.java     |  23 +-
 .../rat/analysis/HeaderCheckWorkerTest.java   |   2 -
 .../org/apache/rat/commandline/ArgTests.java  |   6 -
 .../exclusion/ExclusionProcessorTest.java     |  33 +--
 .../rat/report/claim/ClaimStatisticTest.java  |  41 ++--
 .../data/AbstractTestDataProvider.java        |   1 -
 .../resources/XmlOutputExamples/elements.xml  |  14 +-
 pom.xml                                       |  13 ++
 22 files changed, 439 insertions(+), 231 deletions(-)
 create mode 100644 apache-rat-core/src/test/java/org/apache/rat/OutputTest.java

diff --git a/apache-rat-core/pom.xml b/apache-rat-core/pom.xml
index 21f0c583c..061670044 100644
--- a/apache-rat-core/pom.xml
+++ b/apache-rat-core/pom.xml
@@ -263,5 +263,10 @@
       <artifactId>jimfs</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.xmlunit</groupId>
+      <artifactId>xmlunit-assertj3</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 </project>
diff --git a/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java b/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
index 027619288..34cf3909d 100644
--- a/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
+++ b/apache-rat-core/src/it/java/org/apache/rat/ReportTest.java
@@ -80,7 +80,7 @@
  *      associated with the exception.</li>
  * </ul>
  */
-public class ReportTest {
+class ReportTest {
 
     private String[] asArgs(final List<String> argsList) {
         return argsList.toArray(new String[0]);
@@ -88,7 +88,7 @@ private String[] asArgs(final List<String> argsList) {
 
     @ParameterizedTest(name = "{index} {0}")
     @MethodSource("args")
-    public void integrationTest(String testName, Document commandLineDoc) throws Exception {
+    void integrationTest(String testName, Document commandLineDoc) throws Exception {
         DefaultLog.getInstance().log(Log.Level.INFO, "Running test for " + testName);
         File baseDir = new File(commandLineDoc.getName().getName()).getParentFile();
 
@@ -119,9 +119,11 @@ public void integrationTest(String testName, Document commandLineDoc) throws Exc
 
             File expectedMsg = new File(baseDir, "expected-message.txt");
             if (expectedMsg.exists()) {
-                String msg = IOUtils.readLines(new FileReader(expectedMsg)).get(0).trim();
-                assertThrows(RatDocumentAnalysisException.class, () -> Report.main(asArgs(argsList)),
-                        msg);
+                try (FileReader fr = new FileReader(expectedMsg)) {
+                    String msg = IOUtils.readLines(fr).get(0).trim();
+                    assertThrows(RatDocumentAnalysisException.class, () -> Report.main(asArgs(argsList)),
+                            msg);
+                }
             } else {
                 Report.main(asArgs(argsList));
             }
@@ -204,6 +206,7 @@ public static class FileLog implements Log {
          *
          * @param level the level to use when writing messages.
          */
+        @Override
         public void setLevel(final Level level) {
             this.level = level;
         }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/ConfigurationException.java b/apache-rat-core/src/main/java/org/apache/rat/ConfigurationException.java
index d5add9fed..f8a94cb2d 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ConfigurationException.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ConfigurationException.java
@@ -26,8 +26,8 @@ public class ConfigurationException extends RuntimeException {
     private static final long serialVersionUID = 7257245932787579431L;
 
     public static ConfigurationException from(final Exception e) {
-        if (e instanceof ConfigurationException) {
-            return (ConfigurationException) e;
+        if (e instanceof ConfigurationException exists) {
+            return exists;
         }
         return new ConfigurationException(e);
     }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Defaults.java b/apache-rat-core/src/main/java/org/apache/rat/Defaults.java
index 87c7ed8df..16850e7b0 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Defaults.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Defaults.java
@@ -49,7 +49,8 @@ public final class Defaults {
     /** The default configuration file from the package. */
     private static final URI DEFAULT_CONFIG_URI;
     /** The path to the default configuration file. */
-    private static final String DEFAULT_CONFIG_PATH = "/org/apache/rat/default.xml";
+    // sonar wants this to be configurable.
+    private static final String DEFAULT_CONFIG_PATH = "/org/apache/rat/default.xml"; // NOSONAR
     /** The default ARCHIVES processing style. */
     public static final ReportConfiguration.Processing ARCHIVE_PROCESSING = ReportConfiguration.Processing.NOTIFICATION;
     /** The default STANDARD processing style. */
diff --git a/apache-rat-core/src/main/java/org/apache/rat/ImplementationException.java b/apache-rat-core/src/main/java/org/apache/rat/ImplementationException.java
index 76bd2f7c9..17fc47243 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ImplementationException.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ImplementationException.java
@@ -26,8 +26,8 @@ public class ImplementationException extends RuntimeException {
     private static final long serialVersionUID = 7257245932787579431L;
 
     public static ImplementationException makeInstance(final Exception e) {
-        if (e instanceof ImplementationException) {
-            return (ImplementationException) e;
+        if (e instanceof ImplementationException exists) {
+            return exists;
         }
         return new ImplementationException(e);
     }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
index 6e76d035a..a870ce166 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/OptionCollectionParser.java
@@ -87,6 +87,15 @@ public static CommandLine parseCommandLine(final Options opts, final String[] ar
         }
     }
 
+    private void printHelp(final ArgumentContext argumentContext) throws RatException {
+        try {
+            new Licenses(argumentContext.getConfiguration(),
+                    new PrintWriter(argumentContext.getConfiguration().getOutput().get(),
+                            false, StandardCharsets.UTF_8)).printHelp();
+        } catch (IOException e) {
+            throw new RatException("Unable to print help: " + e.getMessage(), e);
+        }
+    }
     /**
      * Parses the standard options to create a ReportConfiguration.
      *
@@ -103,13 +112,7 @@ private ArgumentContext parseCommands(final File workingDirectory, final String[
             Arg.processLogLevel(argumentContext, uiOptionCollection);
             populateConfiguration(argumentContext);
             if (uiOptionCollection.isSelected(Arg.HELP_LICENSES)) {
-                try {
-                    new Licenses(argumentContext.getConfiguration(),
-                            new PrintWriter(argumentContext.getConfiguration().getOutput().get(),
-                                    false, StandardCharsets.UTF_8)).printHelp();
-                } catch (IOException e) {
-                    throw new RatException("Unable to print help: " + e.getMessage(), e);
-                }
+                printHelp(argumentContext);
             }
             return argumentContext;
         } catch (ParseException e) {
diff --git a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
index 3f3825f2e..de97ebadc 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/ReportConfiguration.java
@@ -37,6 +37,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.SortedSet;
+import java.util.stream.Stream;
 
 import javax.xml.parsers.DocumentBuilder;
 
@@ -73,8 +74,6 @@
 import org.w3c.dom.Node;
 import org.xml.sax.SAXException;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
 /**
  * A configuration object is used by the front end to invoke the
  * {@link Reporter}. The sole purpose of the frontends is to create the
@@ -82,7 +81,7 @@
  */
 public class ReportConfiguration {
 
-    /** The IODescriptor for System.out */
+    /** The IODescriptor for system.out */
     public static final IODescriptor<OutputStream> SYSTEM_OUT =
             // SONAR wants to require logging output, which is the wrong reporting channel for this case.
             new IODescriptor<>("System.out", () -> CloseShieldOutputStream.wrap(System.out)); // NOSONAR
@@ -152,7 +151,7 @@ public String desc() {
     private final List<Reportable> reportables;
 
     /**
-     * A predicate to test if a path should be included in the processing.
+     * The exclusion processor that determines if a file is included or excluded.
      */
     private final ExclusionProcessor exclusionProcessor;
 
@@ -257,6 +256,15 @@ public ReportableListWalker.Builder getSources() {
         return builder;
     }
 
+    // for testing access
+    Iterable<File> sources() {
+        return sources;
+    }
+
+    Stream<DocumentName> reportables() {
+        return reportables.stream().map(Reportable::name);
+    }
+
     /**
      * Gets the matcher that matches generated text.
      * @return the matcher that matches generated text.
@@ -439,6 +447,14 @@ public void addIncludedFilter(final FileFilter fileFilter) {
         exclusionProcessor.addIncludedMatcher(new DocumentNameMatcher(fileFilter));
     }
 
+    /**
+     * Includes files that match a DocumentNameMatcher.
+     * @param matcher the DocumentNameMatcher to match.
+     */
+    public void addIncludedMatcher(final DocumentNameMatcher matcher) {
+        exclusionProcessor.addIncludedMatcher(matcher);
+    }
+
     /**
      * Add file patterns that are to be included. These patterns override any exclusion of
      * the same files.
@@ -457,6 +473,11 @@ public DocumentNameMatcher getDocumentExcluder(final DocumentName baseDir) {
         return exclusionProcessor.getNameMatcher(baseDir);
     }
 
+    // visible for testing.
+    ExclusionProcessor getExclusionProcessor() {
+        return exclusionProcessor;
+    }
+
     /**
      * Gets the IOSupplier with the style sheet.
      * @return the Supplier of the InputStream that is the XSLT style sheet to style
@@ -881,7 +902,6 @@ public void validate() {
      * Deserialized ReportConfigurations can not be executed as the reportable objects a simply named placeholders
      * and do not have access to the original object.
      */
-    @SuppressFBWarnings({"MALICIOUS_XSLT", "XXE_DOCUMENT"})
     public class Serde {
         /**
          * Writes the configuration as an XML document to the appendable.
@@ -906,7 +926,7 @@ public void serialize(final Appendable appendable) throws IOException {
                 }
                 writer.startElement("sources");
                 for (File f : sources) {
-                    writer.startElement("source").attribute("name", f.getName()).closeElement();
+                    writer.startElement("source").attribute("name", f.toString()).closeElement();
                 }
                 writer.closeElement("sources").startElement("reportables");
                 for (Reportable reportable : reportables) {
@@ -946,6 +966,7 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final
                 throw new IOException("Invalid ReportConfiguration");
             }
             Map<String, String> attributes = XMLConfigurationReader.attributes(node);
+            addingLicenses = Boolean.parseBoolean(attributes.get("addingLicenses"));
             addingLicensesForced = Boolean.parseBoolean(attributes.get("addingLicensesForced"));
             listFamilies = LicenseFilter.valueOf(attributes.get("listFamilies"));
             listLicenses = LicenseFilter.valueOf(attributes.get("listLicenses"));
@@ -965,6 +986,9 @@ public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final
                 }
             }
 
+            XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("copyrightMessage"),
+                    lNode -> setCopyrightMessage(lNode.getTextContent()));
+
             XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("source"), lNode -> {
                 Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
                 addSource(new File(nAttributes.get("name")));
@@ -1015,7 +1039,7 @@ public record IODescriptor<T>(String name, IOSupplier<T> ioSupplier) {
          */
         static IODescriptor<OutputStream> output(final String name, final DocumentName workingDirectory) {
             DocumentName docName = workingDirectory.resolve(name);
-            return new IODescriptor<OutputStream>(name, () -> new FileOutputStream(docName.asFile()));
+            return new IODescriptor<>(name, () -> new FileOutputStream(docName.asFile()));
         }
     }
 }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index f4aae5410..a39c3254d 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -48,9 +48,9 @@
 import org.apache.rat.utils.StandardXmlFactory;
 import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.xml.sax.SAXException;
 
 /**
  * Class that executes the report as defined in a {@link ReportConfiguration} and stores
@@ -245,7 +245,7 @@ public Builder document(final Document document) {
                 this.document = document;
                 return this;
             }
-            @SuppressFBWarnings("XXE_DOCUMENT")
+
             public Builder document(final String fileName, final DocumentName workingDirectory) {
                 DocumentBuilder builder = StandardXmlFactory.documentBuilder();
                 File inputFile = workingDirectory.resolve(fileName).asFile();
diff --git a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
index 83c962530..fe0713f9a 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/config/exclusion/ExclusionProcessor.java
@@ -478,8 +478,11 @@ public void deserialize(final Node xmlNode) {
                                     throw new NotImplementedException("Deserialized ExclusionProcessor can not evaluate paths");
                                 }));
                         break;
+                    case "fileProcessor":
+                        fileProcessors.add(StandardCollection.valueOf(attributes.get(NAME)));
+                        break;
                     default:
-                        throw new NotImplementedException("Deserialization for %s is not implemented", child.getNodeName());
+                        throw new NotImplementedException(String.format("Deserialization for `%s` is not implemented", child.getNodeName()));
                 }
             }
         }
diff --git a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
index 38f4cd08e..5bad70a39 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
@@ -18,7 +18,15 @@
  */
 package org.apache.rat.utils;
 
+import org.w3c.dom.Document;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
 import java.io.InputStream;
+import java.io.StringWriter;
+import java.util.Map;
+import java.util.Properties;
 
 import javax.xml.XMLConstants;
 import javax.xml.parsers.DocumentBuilder;
@@ -27,7 +35,10 @@
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
 import javax.xml.transform.stream.StreamSource;
 
 /**
@@ -53,16 +64,27 @@ private StandardXmlFactory() {
      * @throws TransformerConfigurationException on error.
      */
     public static Transformer create() throws TransformerConfigurationException {
-        return create(null);
+        return create(null, new Properties());
+    }
+
+    /**
+     * Create a transformer with specified style sheet.
+     * @return the transformer.
+     * @throws TransformerConfigurationException on error.
+     */
+    public static Transformer create(InputStream styleIn) throws TransformerConfigurationException {
+        return create(styleIn, new Properties());
     }
 
     /**
-     * Create a transformer with the specified stylesheet.
+     * Create a transformer with the specified stylesheet and additional properties.
+     * By default, the output omits the XML declaration, uses XML output, indents rsult with 4 spaces.
      * @param styleIn the stylesheet to use.
+     * @param transformerProperties Additional output transformer properties.
      * @return the transformer.
      * @throws TransformerConfigurationException on error.
      */
-    public static Transformer create(final InputStream styleIn) throws TransformerConfigurationException {
+    public static Transformer create(final InputStream styleIn, Properties transformerProperties) throws TransformerConfigurationException {
         TransformerFactory factory = TransformerFactory.newInstance();
         factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
         factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
@@ -73,6 +95,9 @@ public static Transformer create(final InputStream styleIn) throws TransformerCo
         transformer.setOutputProperty(OutputKeys.INDENT, "yes");
         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
         transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
+        if (transformerProperties != null) {
+            transformer.setOutputProperties(transformerProperties);
+        }
         return transformer;
     }
 
@@ -94,4 +119,28 @@ public static DocumentBuilder documentBuilder() {
             throw new IllegalStateException("No XML parser defined", e);
         }
     }
+
+    /**
+     * Write an XML document to a file.
+     * @param document the document to write
+     * @param file the file to write to.
+     */
+    public static void writeDocument(final Document document, final File file) throws IOException, TransformerException {
+        DOMSource source = new DOMSource(document);
+        FileWriter writer = new FileWriter(file);
+        StreamResult result = new StreamResult(writer);
+        create().transform(source, result);
+    }
+
+    /**
+     * Write an XML document to a file.
+     * @param document the document to write.
+     */
+    public static String serializeDocument(final Document document) throws IOException, TransformerException {
+        DOMSource source = new DOMSource(document);
+        StringWriter writer = new StringWriter();
+        StreamResult result = new StreamResult(writer);
+        create().transform(source, result);
+        return writer.toString();
+    }
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
index 0da85fb5b..2b2411497 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OptionCollectionParserTest.java
@@ -19,7 +19,6 @@
 package org.apache.rat;
 
 import org.apache.commons.cli.Option;
-import org.apache.commons.cli.ParseException;
 import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.ArgumentContext;
 import org.apache.rat.ui.UIOption;
@@ -29,7 +28,6 @@
 import org.junit.jupiter.api.io.CleanupMode;
 import org.junit.jupiter.api.io.TempDir;
 
-import java.io.IOException;
 import java.nio.file.Path;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
new file mode 100644
index 000000000..67e19f0ff
--- /dev/null
+++ b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
@@ -0,0 +1,167 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one   *
+ * or more contributor license agreements.  See the NOTICE file *
+ * distributed with this work for additional information        *
+ * regarding copyright ownership.  The ASF licenses this file   *
+ * to you under the Apache License, Version 2.0 (the            *
+ * "License"); you may not use this file except in compliance   *
+ * with the License.  You may obtain a copy of the License at   *
+ *                                                              *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
+ *                                                              *
+ * Unless required by applicable law or agreed to in writing,   *
+ * software distributed under the License is distributed on an  *
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
+ * KIND, either express or implied.  See the License for the    *
+ * specific language governing permissions and limitations      *
+ * under the License.                                           *
+ */
+package org.apache.rat;
+
+import org.apache.rat.commandline.StyleSheets;
+import org.apache.rat.config.AddLicenseHeaders;
+import org.apache.rat.config.exclusion.StandardCollection;
+import org.apache.rat.config.results.ClaimValidator;
+import org.apache.rat.document.DocumentName;
+import org.apache.rat.document.DocumentNameMatcher;
+import org.apache.rat.license.LicenseSetFactory;
+import org.apache.rat.report.claim.ClaimStatistic;
+import org.apache.rat.report.claim.ClaimStatisticTest;
+import org.apache.rat.testhelpers.XmlUtils;
+import org.apache.rat.utils.FileUtils;
+import org.apache.rat.utils.StandardXmlFactory;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xmlunit.assertj3.XmlAssert;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.transform.TransformerException;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class OutputTest {
+
+    static Path tempPath;
+
+    @BeforeAll
+    static void setup() throws IOException {
+        tempPath = Files.createTempDirectory("outputTest").toAbsolutePath();
+    }
+
+    @AfterAll
+    static void teardown() throws IOException {
+        FileUtils.delete(tempPath.toFile());
+    }
+
+    @Test
+    void documentReadingTest() throws IOException, SAXException, TransformerException {
+        Path testPath = tempPath.resolve("documentReading");
+        File testFile = testPath.toFile();
+        FileUtils.mkDir(testFile);
+        DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+        Document document;
+        DocumentName documentFile = workingDirectory.resolve("document.xml");
+        try (InputStream inputStream = OutputTest.class.getClassLoader().getResourceAsStream("XmlOutputExamples/elements.xml");) {
+            document = StandardXmlFactory.documentBuilder().parse(inputStream);
+            StandardXmlFactory.writeDocument(document, documentFile.asFile());
+        }
+
+        Reporter.Output.Builder builder = Reporter.Output.builder().document(documentFile.getName(), workingDirectory);
+
+        Reporter.Output output = builder.build();
+        XmlAssert.assertThat(output.getDocument()).and(document)
+                .ignoreWhitespace()
+                .areIdentical();
+    }
+
+    @Test
+    void stasticReadingTest() throws IOException, SAXException, TransformerException {
+        Path testPath = tempPath.resolve("statisticReading");
+        File testFile = testPath.toFile();
+        FileUtils.mkDir(testFile);
+        DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+        DocumentName documentFile = workingDirectory.resolve("statistic.xml");
+
+        ClaimStatistic underTest = new ClaimStatistic();
+        underTest.incLicenseCategoryCount("familyCagegory", 1);
+        underTest.incCounter(ClaimStatistic.Counter.APPROVED, 2);
+        underTest.incCounter(org.apache.rat.api.Document.Type.IGNORED, 3);
+        underTest.incLicenseNameCount("licenseName", 4);
+
+        ClaimStatistic.Serde serde = underTest.serde();
+        StringWriter stringWriter = new StringWriter();
+        serde.serialize(stringWriter);
+        try (FileOutputStream fos = new FileOutputStream(documentFile.asFile())) {
+            fos.write(stringWriter.toString().getBytes(StandardCharsets.UTF_8));
+        }
+
+        Reporter.Output.Builder builder = Reporter.Output.builder().statistic(documentFile.getName(), workingDirectory);
+
+        Reporter.Output output = builder.build();
+        ClaimStatisticTest.assertSame(output.getStatistic(), underTest);
+    }
+
+    @Test
+    void configurationReadingTest() throws IOException, SAXException, TransformerException {
+        Path testPath = tempPath.resolve("configurationReading");
+        File testFile = testPath.toFile();
+        FileUtils.mkDir(testFile);
+        DocumentName workingDirectory = DocumentName.builder(testPath.toFile()).setBaseName(testFile).build();
+        DocumentName documentFile = workingDirectory.resolve("configuration.xml");
+
+        ReportConfiguration underTest = new ReportConfiguration();
+        underTest.setAddLicenseHeaders(AddLicenseHeaders.FORCED);
+        underTest.listFamilies(LicenseSetFactory.LicenseFilter.APPROVED);
+        underTest.listLicenses(LicenseSetFactory.LicenseFilter.ALL);
+        underTest.setDryRun(true);
+        underTest.setArchiveProcessing(ReportConfiguration.Processing.NOTIFICATION);
+        underTest.setStandardProcessing(ReportConfiguration.Processing.ABSENCE);
+        underTest.setStyleSheet(StyleSheets.MISSING_HEADERS.getStyleSheet());
+        underTest.setOut(new File("/some/file/somewhere"));
+        underTest.setCopyrightMessage("the copyright message");
+        underTest.addSource(new File("/my/file"));
+        underTest.addSource(new ReportConfigurationTest.TestingReportable());
+        underTest.addExcludedPatterns(List.of("pattern/**", "pattern2/**"));
+        underTest.addExcludedCollection(StandardCollection.BAZAAR);
+        underTest.addExcludedCollection(StandardCollection.MISC);
+        underTest.addExcludedFileProcessor(StandardCollection.HIDDEN_FILE);
+        underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL);
+        underTest.addIncludedPatterns(List.of("**/pattern3", "**/pattern4"));
+        underTest.addIncludedCollection(StandardCollection.ARCH);
+        underTest.addIncludedCollection(StandardCollection.BITKEEPER);
+        underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+        ClaimValidator claimValidator = underTest.getClaimValidator();
+        claimValidator.setMax(ClaimStatistic.Counter.APPROVED, 5);
+        claimValidator.setMin(ClaimStatistic.Counter.APPROVED, 3);
+        claimValidator.setMax(ClaimStatistic.Counter.ARCHIVES, 10);
+        claimValidator.setMin(ClaimStatistic.Counter.BINARIES, 4);
+
+        StringWriter stringWriter = new StringWriter();
+        underTest.serde().serialize(stringWriter);
+
+        try (FileOutputStream fos = new FileOutputStream(documentFile.asFile())) {
+            fos.write(stringWriter.toString().getBytes(StandardCharsets.UTF_8));
+        }
+
+        Reporter.Output.Builder builder = Reporter.Output.builder().configuration(documentFile.getName(), workingDirectory);
+
+        Reporter.Output output = builder.build();
+        ReportConfigurationTest.assertSame(output.getConfiguration(), underTest);
+    }
+}
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
index 68c2c30af..d18f4e2ac 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
@@ -24,6 +24,7 @@
 import static org.mockito.Mockito.when;
 
 import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
@@ -31,35 +32,36 @@
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 import java.util.SortedSet;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import org.apache.commons.io.filefilter.DirectoryFileFilter;
-import org.apache.commons.io.function.IOSupplier;
 import org.apache.commons.io.output.CloseShieldOutputStream;
-import org.apache.commons.lang3.StringUtils;
 import org.apache.rat.analysis.IHeaderMatcher;
+import org.apache.rat.api.RatException;
 import org.apache.rat.commandline.StyleSheets;
 import org.apache.rat.config.AddLicenseHeaders;
+import org.apache.rat.config.exclusion.ExclusionProcessorTest;
 import org.apache.rat.config.exclusion.StandardCollection;
-import org.apache.rat.configuration.XMLConfigurationReader;
+import org.apache.rat.config.results.ClaimValidator;
 import org.apache.rat.configuration.XMLConfigurationReaderTest;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.license.ILicense;
 import org.apache.rat.license.ILicenseFamily;
 import org.apache.rat.license.LicenseSetFactory.LicenseFilter;
+import org.apache.rat.report.RatReport;
 import org.apache.rat.report.Reportable;
 import org.apache.rat.report.claim.ClaimStatistic;
-import org.apache.rat.report.xml.writer.XmlWriter;
 import org.apache.rat.testhelpers.TestingLog;
 import org.apache.rat.testhelpers.TestingLicense;
 import org.apache.rat.testhelpers.TestingMatcher;
@@ -72,12 +74,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.mockito.Mockito;
-import org.w3c.dom.Node;
-import org.xml.sax.SAXException;
 
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 
 public class ReportConfigurationTest {
 
@@ -748,6 +745,66 @@ public static void validateDefault(ReportConfiguration config) {
         validateDefaultApprovedLicenses(config);
     }
 
+    public static void assertSame(ReportConfiguration actual, ReportConfiguration expected) {
+        assertThat(actual.isAddingLicenses()).isEqualTo(expected.isAddingLicenses());
+        assertThat(actual.isAddingLicensesForced()).isEqualTo(expected.isAddingLicensesForced());
+        assertThat(actual.listFamilies()).isEqualTo(expected.listFamilies());
+        assertThat(actual.listLicenses()).isEqualTo(expected.listLicenses());
+        assertThat(actual.isDryRun()).isEqualTo(expected.isDryRun());
+        assertThat(actual.getArchiveProcessing()).isEqualTo(expected.getArchiveProcessing());
+        assertThat(actual.getStandardProcessing()).isEqualTo(expected.getStandardProcessing());
+        assertThat(actual.getStyleSheetDescriptor().name()).isEqualTo(expected.getStyleSheetDescriptor().name());
+        assertThat(actual.getOutputDescriptor().name()).isEqualTo(expected.getOutputDescriptor().name());
+
+        assertThat(actual.getCopyrightMessage()).isEqualTo(expected.getCopyrightMessage());
+
+        assertThat(actual.sources()).containsExactlyElementsOf(expected.sources());
+        assertThat(actual.reportables()).containsExactlyElementsOf(expected.reportables().toList());
+        ExclusionProcessorTest.assertSame(actual.getExclusionProcessor(), expected.getExclusionProcessor());
+
+    }
+    @Test
+    void serdeTest() throws IOException {
+        ReportConfiguration underTest = new ReportConfiguration();
+
+        underTest.setAddLicenseHeaders(AddLicenseHeaders.FORCED);
+        underTest.listFamilies(LicenseFilter.APPROVED);
+        underTest.listLicenses(LicenseFilter.ALL);
+        underTest.setDryRun(true);
+        underTest.setArchiveProcessing(ReportConfiguration.Processing.NOTIFICATION);
+        underTest.setStandardProcessing(ReportConfiguration.Processing.ABSENCE);
+        underTest.setStyleSheet(StyleSheets.MISSING_HEADERS.getStyleSheet());
+        underTest.setOut(new File("/some/file/somewhere"));
+        underTest.setCopyrightMessage("the copyright message");
+        underTest.addSource(new File("/my/file"));
+        underTest.addSource(new TestingReportable());
+
+        underTest.addExcludedPatterns(List.of("pattern/**", "pattern2/**"));
+        underTest.addExcludedCollection(StandardCollection.BAZAAR);
+        underTest.addExcludedCollection(StandardCollection.MISC);
+        underTest.addExcludedFileProcessor(StandardCollection.HIDDEN_FILE);
+        underTest.addExcludedMatcher(DocumentNameMatcher.MATCHES_ALL);
+        underTest.addIncludedPatterns(List.of("**/pattern3", "**/pattern4"));
+        underTest.addIncludedCollection(StandardCollection.ARCH);
+        underTest.addIncludedCollection(StandardCollection.BITKEEPER);
+        underTest.addIncludedMatcher(DocumentNameMatcher.MATCHES_NONE);
+
+        ClaimValidator claimValidator = underTest.getClaimValidator();
+
+        claimValidator.setMax(ClaimStatistic.Counter.APPROVED, 5);
+        claimValidator.setMin(ClaimStatistic.Counter.APPROVED, 3);
+        claimValidator.setMax(ClaimStatistic.Counter.ARCHIVES, 10);
+        claimValidator.setMin(ClaimStatistic.Counter.BINARIES, 4);
+
+        StringWriter stringWriter = new StringWriter();
+        underTest.serde().serialize(stringWriter);
+
+        ReportConfiguration actual = new ReportConfiguration();
+        actual.serde().deserialize(() -> new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)),
+                DocumentName.builder(new File("/rootDir")).build());
+        assertSame(actual, underTest);
+    }
+
     /**
      * A class to act as an output stream and count the number of close operations.
      */
@@ -758,133 +815,26 @@ static class OutputStreamInterceptor extends OutputStream {
         public void write(int arg0) {
             throw new UnsupportedOperationException();
         }
-        
+
         @Override
         public void close() {
             ++closeCount;
         }
     }
 
-//    @Test
-//    void serdeTest() {
-//        ReportConfiguration undertest = new ReportConfiguration();
-//        underTest.setCopyrightMessage("the copyright message");
-//
-//
-//    }
-//
-//    /*
-//        public class Serde {
-//        /**
-//         * Writes the configuration as an XML document to the appendable.
-//         *
-//         * @param appendable the Appendable to write to.
-//         * @throws IOException on error.
-//         */
-//    public void serialize(final Appendable appendable) throws IOException {
-//        try (XmlWriter writer = new XmlWriter(appendable)) {
-//            writer.startElement("ReportConfiguration")
-//                    .attribute("addingLicenses", Boolean.toString(addingLicenses))
-//                    .attribute("addingLicensesForced", Boolean.toString(addingLicensesForced))
-//                    .attribute("listFamilies", listFamilies.name())
-//                    .attribute("listLicenses", listLicenses.name())
-//                    .attribute("dryRun", Boolean.toString(dryRun))
-//                    .attribute("archiveProcessing", getArchiveProcessing().name())
-//                    .attribute("standardProcessing", getStandardProcessing().name())
-//                    .attribute("stylesheet", styleSheet.name())
-//                    .attribute("output", out.name());
-//            if (StringUtils.isNotEmpty(copyrightMessage)) {
-//                writer.startElement("copyrightMessage").content(copyrightMessage).closeElement();
-//            }
-//            writer.startElement("sources");
-//            for (File f : sources) {
-//                writer.startElement("source").attribute("name", f.getName()).closeElement();
-//            }
-//            writer.closeElement("sources").startElement("reportables");
-//            for (Reportable reportable : reportables) {
-//                writer.startElement("reportable")
-//                        .attribute("baseName", reportable.name().getBaseName())
-//                        .attribute("name", reportable.name().toString())
-//                        .attribute("class", reportable.getClass().getName()).closeElement();
-//            }
-//            writer.closeElement();
-//
-//            exclusionProcessor.serde().serialize(writer);
-//
-//            writer.startElement("claimValidator");
-//            for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
-//                writer.startElement("claimCounter")
-//                        .attribute("name", counter.name()).attribute("min", Integer.toString(claimValidator.getMin(counter)))
-//                        .attribute("max", Integer.toString(claimValidator.getMax(counter))).closeElement();
-//            }
-//            writer.closeElement();
-//        } catch (IOException e) {
-//            throw e;
-//        } catch (Exception e) {
-//            throw new IOException(e);
-//        }
-//    }
-//
-//    public void deserialize(final IOSupplier<InputStream> inputStreamSupplier, final DocumentName workingDirectory) throws IOException {
-//        DocumentBuilder builder;
-//        try {
-//            builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
-//        } catch (ParserConfigurationException e) {
-//            throw new ConfigurationException("Unable to create DOM builder", e);
-//        }
-//        org.w3c.dom.Document document;
-//        try (InputStream stream = inputStreamSupplier.get()) {
-//            document = builder.parse(stream);
-//        } catch (SAXException e) {
-//            throw new IOException("Unable to read input", e);
-//        }
-//        Node node = document.getDocumentElement();
-//        if (!node.getNodeName().equals("ReportConfiguration")) {
-//            throw new IOException("Invalid ReportConfiguration");
-//        }
-//        Map<String, String> attributes = XMLConfigurationReader.attributes(node);
-//        addingLicensesForced = Boolean.parseBoolean(attributes.get("addingLicensesForced"));
-//        listFamilies = LicenseFilter.valueOf(attributes.get("listFamilies"));
-//        listLicenses = LicenseFilter.valueOf(attributes.get("listLicenses"));
-//        dryRun = Boolean.parseBoolean(attributes.get("dryRun"));
-//        archiveProcessing = ReportConfiguration.Processing.valueOf(attributes.get("archiveProcessing"));
-//        standardProcessing = ReportConfiguration.Processing.valueOf(attributes.get("standardProcessing"));
-//        String styleName = attributes.get("stylesheet");
-//        if (styleName != null) {
-//            styleSheet = StyleSheets.getStyleSheet(styleName, workingDirectory);
-//        }
-//        String outputName = attributes.get("output");
-//        if (outputName != null) {
-//            if (outputName.equals(ReportConfiguration.SYSTEM_OUT.name())) {
-//                out = ReportConfiguration.SYSTEM_OUT;
-//            } else {
-//                out = ReportConfiguration.IODescriptor.output(outputName, workingDirectory);
-//            }
-//        }
-//
-//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("source"), lNode -> {
-//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
-//            addSource(new File(nAttributes.get("name")));
-//        });
-//
-//        // Deserialize the reportables.
-//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("reportable"), lNode -> {
-//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
-//            DocumentName documentName = DocumentName.builder().setBaseName(nAttributes.get("baseName"))
-//                    .setName(nAttributes.get("name")).build();
-//            addSource(new ReportConfiguration.DeserializedReportable(documentName));
-////        });
-//
-//        exclusionProcessor.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
-//
-//        XMLConfigurationReader.nodeListConsumer(document.getElementsByTagName("claimCounter"), lNode -> {
-//            Map<String, String> nAttributes = XMLConfigurationReader.attributes(lNode);
-//            ClaimStatistic.Counter counter = ClaimStatistic.Counter.valueOf(nAttributes.get("name"));
-//            claimValidator.setMin(counter, Integer.parseInt(nAttributes.get("min")));
-//            claimValidator.setMax(counter, Integer.parseInt(nAttributes.get("max")));
-//        });
-//    }
-//}
-//
-//     */
+    /**
+     * A reportable that only reports its name.  Does no actual work.
+     */
+    static class TestingReportable implements Reportable {
+
+        @Override
+        public void run(RatReport report) throws RatException {
+            // does nothing
+        }
+
+        @Override
+        public DocumentName name() {
+            return DocumentName.builder().setBaseName("").setName("TestingReportable").build();
+        }
+    }
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
index be39b3608..67ad8fd7b 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterOptionsProvider.java
@@ -20,15 +20,11 @@
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileReader;
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
-import java.io.Reader;
-import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.Arrays;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 6e7e7f2db..540c1dd1c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -7,7 +7,7 @@
  * "License"); you may not use this file except in compliance   *
  * with the License.  You may obtain a copy of the License at   *
  *                                                              *
- *   http://www.apache.org/licenses/LICENSE-2.0                 *
+ *   https://www.apache.org/licenses/LICENSE-2.0                 *
  *                                                              *
  * Unless required by applicable law or agreed to in writing,   *
  * software distributed under the License is distributed on an  *
@@ -73,7 +73,6 @@
 import org.apache.rat.testhelpers.data.ValidatorData;
 import org.apache.rat.walker.DirectoryWalker;
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -141,7 +140,7 @@ void setUpTest(TestInfo testInfo) {
     }
 
     @Test
-    void testExecute() throws RatException, ParseException, IOException {
+    void testExecute() throws RatException {
         File output = testPath.resolve("output.xml").toFile();
         ArgumentContext ctxt = collectionParser.parseCommands(new File("."), new String[]{"--output-style", "xml", "--output-file", output.getPath(), basedir});
         ClaimStatistic statistic = new Reporter(ctxt.getConfiguration()).execute().getStatistic();
@@ -587,15 +586,15 @@ void testReportData(String name, TestData test) throws Exception {
     }
 
     private record LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
-            LicenseInfo(String id, boolean approval, boolean hasNotes) {
-                this(id, id, approval, hasNotes);
-            }
+        LicenseInfo(String id, boolean approval, boolean hasNotes) {
+            this(id, id, approval, hasNotes);
+        }
 
-            private LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
-                this.id = id;
-                this.family = ILicenseFamily.makeCategory(family);
-                this.approval = approval;
-                this.hasNotes = hasNotes;
-            }
+        private LicenseInfo(String id, String family, boolean approval, boolean hasNotes) {
+            this.id = id;
+            this.family = ILicenseFamily.makeCategory(family);
+            this.approval = approval;
+            this.hasNotes = hasNotes;
         }
+    }
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
index ec6420aed..02a51085d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/analysis/HeaderCheckWorkerTest.java
@@ -21,7 +21,6 @@
 
 import java.io.StringReader;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -35,7 +34,6 @@
 import org.apache.rat.license.ILicense;
 import org.apache.rat.testhelpers.TestingLicense;
 import org.apache.rat.testhelpers.TestingMatcher;
-import org.assertj.core.util.Lists;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
index 19c2d62b4..b8d0be54d 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
@@ -37,12 +37,6 @@
 
 public class ArgTests {
 
-    private CommandLine createCommandLine(String[] args) throws ParseException {
-        Options opts = OptionCollection.buildOptions();
-        return DefaultParser.builder().setDeprecatedHandler(DeprecationReporter.getLogReporter())
-                .setAllowPartialMatching(true).build().parse(opts, args);
-    }
-
     @ParameterizedTest(name = "{0}")
     @ValueSource(strings = { "rat.txt", "./rat.txt", "/rat.txt", "target/rat.test" })
     public void outputFileNameNoDirectoryTest(String name) throws ParseException {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
index 71e9e7a1a..c30579431 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/config/exclusion/ExclusionProcessorTest.java
@@ -30,7 +30,6 @@
 import org.apache.rat.document.DocumentNameMatcher;
 import org.apache.rat.document.DocumentName;
 import org.apache.rat.report.xml.writer.XmlWriter;
-import org.apache.rat.testhelpers.TextUtils;
 import org.apache.rat.utils.StandardXmlFactory;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -339,6 +338,23 @@ void addNullExcludedPatternTest() {
         assertThat(underTest.getExcludedPatterns()).containsExactly("hello/world");
     }
 
+    public static void assertSame(ExclusionProcessor actual, ExclusionProcessor expected) {
+        assertThat(actual.getExcludedCollections()).containsExactlyElementsOf(expected.getExcludedCollections());
+        assertThat(actual.getFileProcessors()).containsExactlyElementsOf(expected.getFileProcessors());
+        assertThat(actual.getIncludedCollections()).containsExactlyElementsOf(expected.getIncludedCollections());
+        assertThat(actual.getExcludedPatterns()).containsExactlyElementsOf(expected.getExcludedPatterns());
+        assertThat(actual.getIncludedPatterns()).containsExactlyElementsOf(expected.getIncludedPatterns());
+
+        // paths only match on name.  deserialized paths are not functional.
+        List<String> actualPaths = actual.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        List<String> expectedPaths = expected.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).as("excluded paths").containsExactlyElementsOf(expectedPaths);
+
+        actualPaths = actual.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        expectedPaths = expected.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
+        assertThat(actualPaths).as("included paths").containsExactlyElementsOf(expectedPaths);
+    }
+
     @ParameterizedTest
     @MethodSource("serdeTestData")
     void serdeTest(ExclusionProcessor underTest) throws IOException, SAXException {
@@ -349,20 +365,7 @@ void serdeTest(ExclusionProcessor underTest) throws IOException, SAXException {
         Document document = StandardXmlFactory.documentBuilder().parse(new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
         ExclusionProcessor actual = new ExclusionProcessor();
         actual.serde().deserialize(document.getElementsByTagName("ExclusionProcessor").item(0));
-        assertThat(actual.getExcludedCollections()).containsExactlyElementsOf(underTest.getExcludedCollections());
-        assertThat(actual.getFileProcessors()).containsExactlyElementsOf(underTest.getFileProcessors());
-        assertThat(actual.getIncludedCollections()).containsExactlyElementsOf(underTest.getIncludedCollections());
-        assertThat(actual.getExcludedPatterns()).containsExactlyElementsOf(underTest.getExcludedPatterns());
-        assertThat(actual.getIncludedPatterns()).containsExactlyElementsOf(underTest.getIncludedPatterns());
-
-        // paths only match on name.  deserialized paths are not functional.
-        List<String> actualPaths = actual.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
-        List<String> expectedPaths = underTest.getExcludedPaths().stream().map(DocumentNameMatcher::toString).toList();
-        assertThat(actualPaths).as("excluded paths").containsExactlyElementsOf(expectedPaths);
-
-        actualPaths = actual.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
-        expectedPaths = underTest.getIncludedPaths().stream().map(DocumentNameMatcher::toString).toList();
-        assertThat(actualPaths).as("included paths").containsExactlyElementsOf(expectedPaths);
+        assertSame(actual, underTest);
     }
 
     static List<ExclusionProcessor> serdeTestData() {
diff --git a/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
index c2bd6f1ee..ef8a31e2c 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/report/claim/ClaimStatisticTest.java
@@ -27,7 +27,7 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-class ClaimStatisticTest {
+public class ClaimStatisticTest {
 
     @Test
     void counterTests() {
@@ -104,6 +104,29 @@ void licenseFamilyNameTest() {
         assertThat(underTest.getLicenseNames()).containsExactly("neg", "one", "wayToLongAName");
     }
 
+    /**
+     * Compares two claim statistics for similarity after serialization/deserialization.
+     * @param actual the deserialized verison.
+     * @param expected the original version.
+     */
+    public static void assertSame(final ClaimStatistic actual, final ClaimStatistic expected) {
+
+        assertThat(actual.getLicenseFamilyCategories()).containsExactlyElementsOf(expected.getLicenseFamilyCategories());
+        assertThat(actual.getLicenseNames()).containsExactlyElementsOf(expected.getLicenseNames());
+        assertThat(actual.getDocumentTypes()).containsExactlyElementsOf(expected.getDocumentTypes());
+        for (String cat : expected.getLicenseFamilyCategories()) {
+            assertThat(actual.getLicenseCategoryCount(cat)).isEqualTo(expected.getLicenseCategoryCount(cat));
+        }
+        for (String name : expected.getLicenseNames()) {
+            assertThat(actual.getLicenseNameCount(name)).isEqualTo(expected.getLicenseNameCount(name));
+        }
+        for (Document.Type type : expected.getDocumentTypes()) {
+            assertThat(actual.getCounter(type)).isEqualTo(expected.getCounter(type));
+        }
+        for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
+            assertThat(actual.getCounter(counter)).isEqualTo(expected.getCounter(counter));
+        }
+    }
 
     @Test
     void serdeRoundTrip() throws IOException {
@@ -120,20 +143,6 @@ void serdeRoundTrip() throws IOException {
         ClaimStatistic.Serde serde2 = actual.serde();
         serde2.deserialize(() -> new ByteArrayInputStream(stringWriter.toString().getBytes(StandardCharsets.UTF_8)));
 
-        assertThat(actual.getLicenseFamilyCategories()).containsExactlyElementsOf(underTest.getLicenseFamilyCategories());
-        assertThat(actual.getLicenseNames()).containsExactlyElementsOf(underTest.getLicenseNames());
-        assertThat(actual.getDocumentTypes()).containsExactlyElementsOf(underTest.getDocumentTypes());
-        for (String cat : underTest.getLicenseFamilyCategories()) {
-            assertThat(actual.getLicenseCategoryCount(cat)).isEqualTo(underTest.getLicenseCategoryCount(cat));
-        }
-        for (String name : underTest.getLicenseNames()) {
-            assertThat(actual.getLicenseNameCount(name)).isEqualTo(underTest.getLicenseNameCount(name));
-        }
-        for (Document.Type type : underTest.getDocumentTypes()) {
-            assertThat(actual.getCounter(type)).isEqualTo(underTest.getCounter(type));
-        }
-        for (ClaimStatistic.Counter counter : ClaimStatistic.Counter.values()) {
-            assertThat(actual.getCounter(counter)).isEqualTo(underTest.getCounter(counter));
-        }
+        assertSame(actual, underTest);
     }
 }
diff --git a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
index 92c8feca5..d72ea19b5 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/testhelpers/data/AbstractTestDataProvider.java
@@ -35,7 +35,6 @@
 import org.apache.rat.ui.UIOptionCollection;
 import org.apache.rat.ui.ArgumentTracker;
 import org.apache.rat.utils.DefaultLog;
-import org.apache.rat.utils.Log;
 
 /**
  * Generates a list of TestData for executing the Report.
diff --git a/apache-rat-core/src/test/resources/XmlOutputExamples/elements.xml b/apache-rat-core/src/test/resources/XmlOutputExamples/elements.xml
index 4f1c340f9..b2ca96372 100644
--- a/apache-rat-core/src/test/resources/XmlOutputExamples/elements.xml
+++ b/apache-rat-core/src/test/resources/XmlOutputExamples/elements.xml
@@ -1,4 +1,8 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!--
+ This file does intentionally *NOT* contain an AL license header,
+ because it is used in the test suite.
+-->
 <rat-report timestamp="2024-03-29T15:04:42+01:00">
     <resource name="src/test/resources/elements/ILoggerFactory.java" type="STANDARD">
         <license approval="true" family="MIT  " id="MIT" name="The MIT License"/>
@@ -8,16 +12,6 @@
     <resource name="src/test/resources/elements/NOTICE" type="NOTICE"/>
     <resource name="src/test/resources/elements/Source.java" type="STANDARD">
         <license approval="false" family="?????" id="?????" name="Unknown license"/>
-        <sample><![CDATA[ package elements;
-
-/*
- * This file does intentionally *NOT* contain an AL license header,
- * because it is used in the test suite.
- */
-public class Source {
-
-}
- ]]></sample>
     </resource>
     <resource name="src/test/resources/elements/Text.txt" type="STANDARD">
         <license approval="true" family="AL   " id="AL" name="Apache License 2.0"/>
diff --git a/pom.xml b/pom.xml
index 48c8bf720..d1cd1723c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -61,6 +61,7 @@ agnostic home for software distribution comprehension and audit tools.
     <creadur.jira.id>RAT</creadur.jira.id>
     <velocity.core.version>2.4.1</velocity.core.version>
     <velocity.tools.version>3.1</velocity.tools.version>
+    <xmlunit.version>2.12.0</xmlunit.version>
     <!-- maven plugin versions -->
     <mavenPluginTestingVersion>3.5.1</mavenPluginTestingVersion>
     <mavenPluginPluginVersion>3.15.2</mavenPluginPluginVersion>
@@ -268,6 +269,18 @@ agnostic home for software distribution comprehension and audit tools.
         <version>1.3.1</version>
         <scope>test</scope>
       </dependency>
+      <dependency>
+        <groupId>org.xmlunit</groupId>
+        <artifactId>xmlunit-assertj3</artifactId>
+        <version>${xmlunit.version}</version>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>org.xmlunit</groupId>
+        <artifactId>xmlunit-core</artifactId>
+        <version>${xmlunit.version}</version>
+        <scope>test</scope>
+      </dependency>
     </dependencies>
   </dependencyManagement>
   <reporting>

From 3a47cd2918c54d1609e2222e2f6454f9178e95db Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sat, 27 Jun 2026 09:07:18 +0100
Subject: [PATCH 35/36] cleaned up checkstyle issues

---
 .../src/main/java/org/apache/rat/Reporter.java        |  4 ----
 .../java/org/apache/rat/utils/StandardXmlFactory.java | 11 ++++++-----
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
index a39c3254d..f66abb598 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/Reporter.java
@@ -48,8 +48,6 @@
 import org.apache.rat.utils.StandardXmlFactory;
 import org.w3c.dom.Document;
 import org.xml.sax.InputSource;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.xml.sax.SAXException;
 
 /**
@@ -194,7 +192,6 @@ public void format(final ReportConfiguration config) throws RatException {
          * @param output the output stream to write to.
          * @throws RatException on error.
          */
-        @SuppressFBWarnings({"MALICIOUS_XSLT", "XXE_DTD_TRANSFORM_FACTORY", " XXE_XSLT_TRANSFORM_FACTORY"})
         public void format(final IOSupplier<InputStream> stylesheet, final IOSupplier<OutputStream> output) throws RatException {
             TransformerFactory tf = TransformerFactory.newInstance();
             Transformer transformer;
@@ -227,7 +224,6 @@ public void writeSummary(final Appendable appendable) throws IOException {
             }
         }
 
-        @SuppressFBWarnings("EI_EXPOSE_REP2")
         public static final class Builder {
             /** The document that was generated */
             private Document document;
diff --git a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
index 5bad70a39..f204e6e20 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
@@ -18,14 +18,11 @@
  */
 package org.apache.rat.utils;
 
-import org.w3c.dom.Document;
-
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringWriter;
-import java.util.Map;
 import java.util.Properties;
 
 import javax.xml.XMLConstants;
@@ -41,6 +38,9 @@
 import javax.xml.transform.stream.StreamResult;
 import javax.xml.transform.stream.StreamSource;
 
+import org.w3c.dom.Document;
+
+
 /**
  * Factory to create standard XML objects. The intention of this class is to resolve in a consistent manner the
  * XXE errors and similar XML IO errors.
@@ -69,10 +69,11 @@ public static Transformer create() throws TransformerConfigurationException {
 
     /**
      * Create a transformer with specified style sheet.
+     * @param styleIn the style sheet input stream
      * @return the transformer.
      * @throws TransformerConfigurationException on error.
      */
-    public static Transformer create(InputStream styleIn) throws TransformerConfigurationException {
+    public static Transformer create(final InputStream styleIn) throws TransformerConfigurationException {
         return create(styleIn, new Properties());
     }
 
@@ -84,7 +85,7 @@ public static Transformer create(InputStream styleIn) throws TransformerConfigur
      * @return the transformer.
      * @throws TransformerConfigurationException on error.
      */
-    public static Transformer create(final InputStream styleIn, Properties transformerProperties) throws TransformerConfigurationException {
+    public static Transformer create(final InputStream styleIn, final Properties transformerProperties) throws TransformerConfigurationException {
         TransformerFactory factory = TransformerFactory.newInstance();
         factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
         factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");

From 0b664d657ee6a313bee1e07cea1cb9c362d86171 Mon Sep 17 00:00:00 2001
From: Claude Warren <claude@xenei.com>
Date: Sat, 27 Jun 2026 09:35:18 +0100
Subject: [PATCH 36/36] cleaned up SonarQube issues

---
 .../java/org/apache/rat/utils/StandardXmlFactory.java |  2 +-
 .../src/test/java/org/apache/rat/OutputTest.java      | 11 ++---------
 .../java/org/apache/rat/ReportConfigurationTest.java  |  2 --
 .../src/test/java/org/apache/rat/ReporterTest.java    |  1 -
 .../java/org/apache/rat/commandline/ArgTests.java     |  5 -----
 5 files changed, 3 insertions(+), 18 deletions(-)

diff --git a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
index f204e6e20..9b833fbf5 100644
--- a/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
+++ b/apache-rat-core/src/main/java/org/apache/rat/utils/StandardXmlFactory.java
@@ -137,7 +137,7 @@ public static void writeDocument(final Document document, final File file) throw
      * Write an XML document to a file.
      * @param document the document to write.
      */
-    public static String serializeDocument(final Document document) throws IOException, TransformerException {
+    public static String serializeDocument(final Document document) throws TransformerException {
         DOMSource source = new DOMSource(document);
         StringWriter writer = new StringWriter();
         StreamResult result = new StreamResult(writer);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
index 67e19f0ff..32602b60e 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/OutputTest.java
@@ -27,22 +27,17 @@
 import org.apache.rat.license.LicenseSetFactory;
 import org.apache.rat.report.claim.ClaimStatistic;
 import org.apache.rat.report.claim.ClaimStatisticTest;
-import org.apache.rat.testhelpers.XmlUtils;
 import org.apache.rat.utils.FileUtils;
 import org.apache.rat.utils.StandardXmlFactory;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xmlunit.assertj3.XmlAssert;
 
-import javax.xml.parsers.DocumentBuilder;
 import javax.xml.transform.TransformerException;
-import java.io.ByteArrayInputStream;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -52,8 +47,6 @@
 import java.nio.file.Path;
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 class OutputTest {
 
     static Path tempPath;
@@ -90,7 +83,7 @@ void documentReadingTest() throws IOException, SAXException, TransformerExceptio
     }
 
     @Test
-    void stasticReadingTest() throws IOException, SAXException, TransformerException {
+    void stasticReadingTest() throws IOException {
         Path testPath = tempPath.resolve("statisticReading");
         File testFile = testPath.toFile();
         FileUtils.mkDir(testFile);
@@ -117,7 +110,7 @@ void stasticReadingTest() throws IOException, SAXException, TransformerException
     }
 
     @Test
-    void configurationReadingTest() throws IOException, SAXException, TransformerException {
+    void configurationReadingTest() throws IOException {
         Path testPath = tempPath.resolve("configurationReading");
         File testFile = testPath.toFile();
         FileUtils.mkDir(testFile);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
index d18f4e2ac..d6c492c15 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReportConfigurationTest.java
@@ -765,8 +765,6 @@ public static void assertSame(ReportConfiguration actual, ReportConfiguration ex
     }
     @Test
     void serdeTest() throws IOException {
-        ReportConfiguration underTest = new ReportConfiguration();
-
         underTest.setAddLicenseHeaders(AddLicenseHeaders.FORCED);
         underTest.listFamilies(LicenseFilter.APPROVED);
         underTest.listLicenses(LicenseFilter.ALL);
diff --git a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
index 540c1dd1c..9472ba3df 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/ReporterTest.java
@@ -52,7 +52,6 @@
 import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathFactory;
 
-import org.apache.commons.cli.ParseException;
 import org.apache.commons.io.FileUtils;
 import org.apache.rat.api.Document.Type;
 import org.apache.rat.api.RatException;
diff --git a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
index b8d0be54d..bd8affac4 100644
--- a/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
+++ b/apache-rat-core/src/test/java/org/apache/rat/commandline/ArgTests.java
@@ -18,13 +18,8 @@
  */
 package org.apache.rat.commandline;
 
-import org.apache.commons.cli.CommandLine;
-import org.apache.commons.cli.DefaultParser;
-import org.apache.commons.cli.Options;
 import org.apache.commons.cli.ParseException;
 import org.apache.rat.CLIOptionCollection;
-import org.apache.rat.DeprecationReporter;
-import org.apache.rat.OptionCollection;
 import org.apache.rat.ReportConfiguration;
 import org.apache.rat.document.DocumentName;
 import org.junit.jupiter.params.ParameterizedTest;