Adv/add jaccoco

docs/File-size-benchmark.txt

@@ -1,3 +1,19 @@
+====
+    Copyright 2016-2025 chronicle.software
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+====
+
 Warmed up
 messageSize 64
 messages 488110620

docs/RunLargeQueueMain-report.txt

@@ -1,3 +1,19 @@
+====
+    Copyright 2016-2025 chronicle.software
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+====
+
 1: Took 1.413 seconds to write and 0.354 seconds to read 1 GB
 2: Took 1.253 seconds to write and 0.456 seconds to read 1 GB
 3: Took 1.236 seconds to write and 0.246 seconds to read 1 GB

src/main/java/net/openhft/chronicle/queue/ChronicleQueue.java

@@ -366,8 +366,11 @@ default <T> VanillaMethodWriterBuilder<T> methodWriterBuilder(@NotNull final Cla
      * The value returned is always a power of two.
      *
      * @return the Delta Checkpoint Interval for this ChronicleQueue
+     * @deprecated This configuration is no longer used by the queue implementation and is
+     * scheduled for removal in release x.29. There is no direct replacement; callers should
+     * avoid depending on this value and rely on default queue behavior instead.
      */
-    @Deprecated(/* to be removed in x.29 */)
+    @Deprecated
     default int deltaCheckpointInterval() {
         return 64;
     }

src/main/java/net/openhft/chronicle/queue/internal/util/InternalFileUtil.java

@@ -58,11 +58,15 @@ private InternalFileUtil() {
      *
      * <pre>{@code
      *     for (File file : removableFileCandidates(baseDir).collect(Collectors.toList())) {
-     *         if (!file.delete()) {
+     *         try {
+     *             java.nio.file.Files.delete(file.toPath());
+     *         } catch (java.io.IOException e) {
+     *             // Stop at first failure to preserve order guarantees
      *             break;
      *         }
      *     }
-     * }</pre>
+     * }
+     * </pre>
      *
      * @param baseDir containing queue file removal candidates
      * @return a Stream of roll Queue files that are likely removable

src/main/java/net/openhft/chronicle/queue/util/FileUtil.java

@@ -43,11 +43,15 @@ private FileUtil() { }
      *
      * <pre>{@code
      *     for (File file : removableFileCandidates(baseDir).collect(Collectors.toList())) {
-     *         if (!file.delete()) {
+     *         try {
+     *             java.nio.file.Files.delete(file.toPath());
+     *         } catch (java.io.IOException e) {
+     *             // Stop at first failure to preserve order guarantees
      *             break;
      *         }
      *     }
-     * }</pre>
+     * }
+     * </pre>
      *
      * @param baseDir containing queue file removal candidates
      * @return a Stream of roll Queue files that are likely removable

src/main/java/net/openhft/chronicle/queue/util/PretouchUtil.java

@@ -74,14 +74,26 @@ public EventHandler createEventHandler(@NotNull final SingleChronicleQueue queue
         }
 
         /**
-         * Creates a basic {@link Pretoucher} for the specified {@link SingleChronicleQueue}.
+         * Creates a basic no-op {@link Pretoucher} for OSS builds.
          *
-         * @param queue The {@link SingleChronicleQueue} instance
-         * @return A basic {@link Pretoucher} instance
+         * In community (non-enterprise) environments there is no pretoucher implementation;
+         * returning a no-op avoids recursion via ChronicleQueue#createPretoucher()'s default
+         * method, which delegates back to PretouchUtil and would otherwise cause a
+         * StackOverflowError.
          */
         @Override
         public Pretoucher createPretoucher(@NotNull final SingleChronicleQueue queue) {
-            return queue.createPretoucher();
+            return new Pretoucher() {
+                @Override
+                public void execute() {
+                    // intentionally no-op in OSS fallback
+                }
+
+                @Override
+                public void close() {
+                    // intentionally no-op
+                }
+            };
         }
     }
 }

src/test/java/net/openhft/chronicle/queue/ChronicleHistoryReaderMainCliTest.java

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2016-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0
+ */
+package net.openhft.chronicle.queue;
+
+import net.openhft.chronicle.queue.reader.ChronicleHistoryReader;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.Options;
+import org.junit.Test;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.*;
+
+public class ChronicleHistoryReaderMainCliTest extends QueueTestCommon {
+
+    @Test
+    public void runConfiguresReaderFromArguments() throws Exception {
+        final Path queueDir = Files.createTempDirectory("history-reader");
+        final TestChronicleHistoryReaderMain main = new TestChronicleHistoryReaderMain();
+
+        main.run(new String[]{"-d", queueDir.toString(), "-p", "-m", "-t", "SECONDS", "-i", "2", "-w", "5", "-u", "1"});
+
+        RecordingChronicleHistoryReader reader = main.reader;
+        assertTrue(reader.executeCalled);
+        assertTrue(reader.closed);
+        assertEquals(queueDir, reader.basePath());
+        assertTrue(reader.progress());
+        assertTrue(reader.histosByMethod());
+        assertEquals(TimeUnit.SECONDS, reader.timeUnit());
+        assertEquals(2L, reader.ignoreCount());
+        assertEquals(TimeUnit.SECONDS.toNanos(5), reader.measurementWindowNanos());
+        assertEquals(1, reader.summaryOutputOffset());
+        assertNotNull(reader.messageSink());
+    }
+
+    @Test
+    public void parseCommandLineWithHelpOption() {
+        final TestChronicleHistoryReaderMain main = new TestChronicleHistoryReaderMain();
+
+        try {
+            main.parseCommandLine(new String[]{"-h"}, main.options());
+            fail("Expected HelpExit");
+        } catch (HelpExit e) {
+            assertEquals(0, e.status);
+            assertTrue(main.helpOutput.toString().contains("ChronicleHistoryReaderMain"));
+        }
+    }
+
+    @Test
+    public void parseCommandLineMissingDirectoryPrintsError() {
+        final TestChronicleHistoryReaderMain main = new TestChronicleHistoryReaderMain();
+
+        try {
+            main.parseCommandLine(new String[]{"-t", "SECONDS"}, main.options());
+            fail("Expected HelpExit");
+        } catch (HelpExit e) {
+            assertEquals(1, e.status);
+            assertTrue(main.helpOutput.toString().contains("Missing required option"));
+        }
+    }
+
+    private static final class TestChronicleHistoryReaderMain extends ChronicleHistoryReaderMain {
+        final RecordingChronicleHistoryReader reader = new RecordingChronicleHistoryReader();
+        final StringBuilder helpOutput = new StringBuilder();
+
+        @Override
+        protected ChronicleHistoryReader chronicleHistoryReader() {
+            return reader;
+        }
+
+        @Override
+        protected void printHelpAndExit(Options options, int status, String message) {
+            final StringWriter sw = new StringWriter();
+            final PrintWriter pw = new PrintWriter(sw);
+            new org.apache.commons.cli.HelpFormatter().printHelp(
+                    pw,
+                    180,
+                    this.getClass().getSimpleName(),
+                    message,
+                    options,
+                    org.apache.commons.cli.HelpFormatter.DEFAULT_LEFT_PAD,
+                    org.apache.commons.cli.HelpFormatter.DEFAULT_DESC_PAD,
+                    null,
+                    true
+            );
+            pw.flush();
+            helpOutput.append(sw);
+            throw new HelpExit(status);
+        }
+
+        @Override
+        protected CommandLine parseCommandLine(String[] args, Options options) {
+            return super.parseCommandLine(args, options);
+        }
+    }
+
+    private static final class RecordingChronicleHistoryReader extends ChronicleHistoryReader {
+        boolean executeCalled;
+        boolean closed;
+
+        @Override
+        public ChronicleHistoryReader withMessageSink(java.util.function.Consumer<String> messageSink) {
+            return super.withMessageSink(messageSink);
+        }
+
+        @Override
+        public ChronicleHistoryReader withBasePath(Path path) {
+            return super.withBasePath(path);
+        }
+
+        @Override
+        public ChronicleHistoryReader withProgress(boolean p) {
+            return super.withProgress(p);
+        }
+
+        @Override
+        public ChronicleHistoryReader withTimeUnit(TimeUnit p) {
+            return super.withTimeUnit(p);
+        }
+
+        @Override
+        public ChronicleHistoryReader withHistosByMethod(boolean b) {
+            return super.withHistosByMethod(b);
+        }
+
+        @Override
+        public ChronicleHistoryReader withIgnore(long ignore) {
+            return super.withIgnore(ignore);
+        }
+
+        @Override
+        public ChronicleHistoryReader withMeasurementWindow(long measurementWindow) {
+            return super.withMeasurementWindow(measurementWindow);
+        }
+
+        @Override
+        public ChronicleHistoryReader withSummaryOutput(int offset) {
+            return super.withSummaryOutput(offset);
+        }
+
+        @Override
+        public void execute() {
+            executeCalled = true;
+        }
+
+        @Override
+        public void close() {
+            closed = true;
+        }
+
+        Path basePath() {
+            return basePath;
+        }
+
+        boolean progress() {
+            return progress;
+        }
+
+        boolean histosByMethod() {
+            return histosByMethod;
+        }
+
+        TimeUnit timeUnit() {
+            return timeUnit;
+        }
+
+        long ignoreCount() {
+            return ignore;
+        }
+
+        long measurementWindowNanos() {
+            return measurementWindowNanos;
+        }
+
+        int summaryOutputOffset() {
+            return summaryOutputOffset;
+        }
+
+        java.util.function.Consumer<String> messageSink() {
+            return messageSink;
+        }
+    }
+
+    private static final class HelpExit extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+        final int status;
+
+        HelpExit(int status) {
+            this.status = status;
+        }
+    }
+}

src/test/java/net/openhft/chronicle/queue/ChronicleHistoryReaderMainTest.java

@@ -131,25 +131,14 @@ public void testParseCommandLine() {
 
     @Test
     public void testParseCommandLineHelpOption() {
-        ChronicleHistoryReaderMain main = new ChronicleHistoryReaderMain() {
-            @Override
-            protected void printHelpAndExit(Options options, int status, String message) {
-                assertEquals(0, status);  // Ensure help is printed with status 0 (success)
-                throw new ThreadDeath();  // Exit without calling System.exit()
-            }
-        };
+        ChronicleHistoryReaderMain main = new ChronicleHistoryReaderMain();
         String[] args = {"-h"};
 
-        // Manually setting the security manager to catch System.exit() if needed
         try {
             main.run(args);  // Should trigger the help message and exit with 0
-            fail("Expected ThreadDeath to be thrown");
-
-        } catch (ThreadDeath e) {
-            // Expected exception
-
+            fail("Expected SecurityException due to System.exit(0)");
         } catch (SecurityException e) {
-            fail("System.exit was called unexpectedly.");
+            assertTrue(e.getMessage().contains("System exit attempted with status: 0"));
         }
     }
 

src/test/java/net/openhft/chronicle/queue/ChronicleReaderMainCliTest.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0
+ */
+package net.openhft.chronicle.queue;
+
+import net.openhft.chronicle.queue.impl.single.SingleChronicleQueueBuilder;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import static org.junit.Assert.assertTrue;
+
+public class ChronicleReaderMainCliTest extends QueueTestCommon {
+
+    @Test
+    public void mainReadsAndPrintsQueueRecords() {
+        final java.io.File dir = getTmpDir();
+        try (ChronicleQueue queue = SingleChronicleQueueBuilder.binary(dir).build();
+             ExcerptAppender appender = queue.createAppender()) {
+            appender.writeText("hello");
+        }
+
+        final PrintStream originalOut = System.out;
+        final ByteArrayOutputStream capture = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(capture));
+        try {
+            ChronicleReaderMain.main(new String[]{"-d", dir.getAbsolutePath()});
+        } finally {
+            System.setOut(originalOut);
+        }
+
+        final String out = capture.toString();
+        assertTrue("Expected output to contain written text", out.contains("hello"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void invalidContentBasedLimiterClassThrows() {
+        final java.io.File dir = getTmpDir();
+        ChronicleReaderMain main = new ChronicleReaderMain();
+        main.run(new String[]{"-d", dir.getAbsolutePath(), "-cbl", "not.a.RealClass"});
+    }
+
+    @Test(expected = ClassNotFoundException.class)
+    public void invalidBinarySearchComparatorClassThrows() {
+        final java.io.File dir = getTmpDir();
+        ChronicleReaderMain main = new ChronicleReaderMain();
+        main.run(new String[]{"-d", dir.getAbsolutePath(), "-b", "not.a.RealClass"});
+    }
+}