undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/java/lang/Thread/ThreadSleepEvent.java

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @summary Test that Thread.sleep emits a JFR jdk.ThreadSleep event
+ * @requires vm.hasJFR
+ * @modules jdk.jfr
+ * @run junit ThreadSleepEvent
+ */
+
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ThreadFactory;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+import static java.util.concurrent.TimeUnit.*;
+
+import jdk.jfr.Recording;
+import jdk.jfr.consumer.RecordedEvent;
+import jdk.jfr.consumer.RecordingFile;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ThreadSleepEvent {
+    private static final String THREAD_SLEEP_EVENT_NAME = "jdk.ThreadSleep";
+
+    static Stream<ThreadFactory> threadFactories() {
+        return Stream.of(
+                Thread.ofPlatform().factory(),
+                Thread.ofVirtual().factory()
+        );
+    }
+
+    // Arguments.of(ThreadFactory, millis)
+    static Stream<Arguments> threadFactoryAndMillis() {
+        long[] millis = {0, 1000, Long.MAX_VALUE};
+        return threadFactories()
+                .flatMap(f -> LongStream.of(millis)
+                        .mapToObj(ms -> Arguments.of(f, ms)));
+    }
+
+    // Arguments.of(ThreadFactory, millis, nanos)
+    static Stream<Arguments> threadFactoryAndMillisAndNanos() {
+        int[] nanos = {0, 1000, 999_999};
+        return threadFactoryAndMillis().flatMap(a -> IntStream.of(nanos)
+                .mapToObj(ns -> Arguments.of(a.get()[0], a.get()[1], ns)));
+    }
+
+    // Arguments.of(ThreadFactory, Duration)
+    static Stream<Arguments> threadFactoryAndDuration() {
+        Duration[] durations = {
+                Duration.ofNanos(0),
+                Duration.ofSeconds(1),
+                Duration.ofSeconds(Long.MAX_VALUE, 999_999_999)
+        };
+        return threadFactories()
+                .flatMap(f -> Stream.of(durations)
+                        .map(d -> Arguments.of(f, d)));
+    }
+
+    /**
+     * Test Thread.sleep(long) emits event.
+     */
+    @ParameterizedTest
+    @MethodSource("threadFactoryAndMillis")
+    void testSleep(ThreadFactory factory, long millis) throws Exception {
+        long expectedTime = MILLISECONDS.toNanos(millis);
+        long recordedTime = testSleep(factory, () -> Thread.sleep(millis));
+        assertEquals(expectedTime, recordedTime);
+    }
+
+    /**
+     * Test Thread.sleep(long, int) emits event.
+     */
+    @ParameterizedTest
+    @MethodSource("threadFactoryAndMillisAndNanos")
+    void testSleep(ThreadFactory factory, long millis, int nanos) throws Exception {
+        long expectedTime = MILLISECONDS.toNanos(millis);
+        expectedTime += Math.min(Long.MAX_VALUE - expectedTime, nanos);
+        long recordedTime = testSleep(factory, () -> Thread.sleep(millis, nanos));
+        assertEquals(expectedTime, recordedTime);
+    }
+
+    /**
+     * Test Thread.sleep(Duration) emits event.
+     */
+    @ParameterizedTest
+    @MethodSource("threadFactoryAndDuration")
+    void testSleep(ThreadFactory factory, Duration duration) throws Exception {
+        long expectedTime = NANOSECONDS.convert(duration);
+        long recordedTime = testSleep(factory, () -> Thread.sleep(duration));
+        assertEquals(expectedTime, recordedTime);
+    }
+
+    /**
+     * Test that sleeper emits event, returning the recorded sleep time.
+     */
+    long testSleep(ThreadFactory factory, Sleeper sleeper) throws Exception {
+        try (Recording recording = new Recording()) {
+            long tid;
+
+            recording.enable(THREAD_SLEEP_EVENT_NAME);
+            recording.start();
+            try {
+
+                // start thread to run sleeper task
+                var latch = new CountDownLatch(1);
+                Thread thread = factory.newThread(() -> {
+                    latch.countDown();
+                    try {
+                        sleeper.run();
+                    } catch (InterruptedException e) {
+                        // ignore;
+                    }
+                });
+                thread.start();
+
+                // wait for thread to execute
+                latch.await();
+
+                // don't wait for the sleep time
+                thread.interrupt();
+
+                thread.join();
+                tid = thread.threadId();
+            } finally {
+                recording.stop();
+            }
+
+            // find the ThreadSleep event recorded by the thread
+            RecordedEvent event = find(recording, THREAD_SLEEP_EVENT_NAME, tid).orElseThrow();
+            return event.getLong("time");
+        }
+    }
+
+    private interface Sleeper {
+        void run() throws InterruptedException;
+    }
+
+    /**
+     * Find a recorded event with the given name and recorded by a thread with the
+     * given thread ID.
+     */
+    private static Optional<RecordedEvent> find(Recording recording,
+                                                String name,
+                                                long tid) throws Exception {
+        Path recordingFile = recordingFile(recording);
+        List<RecordedEvent> events = RecordingFile.readAllEvents(recordingFile);
+        return events.stream()
+                .filter(e -> e.getEventType().getName().equals(name)
+                        && e.getThread().getJavaThreadId() == tid)
+                .findAny();
+    }
+
+    /**
+     * Return the file path to the recording file.
+     */
+    private static Path recordingFile(Recording recording) throws Exception {
+        Path recordingFile = recording.getDestination();
+        if (recordingFile == null) {
+            ProcessHandle h = ProcessHandle.current();
+            recordingFile = Path.of("recording-" + recording.getId() + "-pid" + h.pid() + ".jfr");
+            recording.dump(recordingFile);
+        }
+        return recordingFile;
+    }
+}