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.
2026-03-26 17:11:57 -04:00 · 2026-03-26 17:11:57 -04:00 · 0a580b313d
commit 0a580b313d
70422 changed files with 17213626 additions and 0 deletions
--- a/test/jdk/java/nio/file/WatchService/LotsOfEntries.java
+++ b/test/jdk/java/nio/file/WatchService/LotsOfEntries.java
@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2024, 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
+ * @bug 8330077
+ * @summary Tests WatchService behavior with more entries in a watched directory
+ *     than the default event limit
+ * @library ..
+ * @run main/othervm LotsOfEntries 600 fail
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=invalid LotsOfEntries 600 fail
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=-5 LotsOfEntries 5 fail
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=5 LotsOfEntries 5 pass
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=5 LotsOfEntries 6 fail
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=700 LotsOfEntries 600 pass
+ * @run main/othervm -Djdk.nio.file.WatchService.maxEventsPerPoll=3000000000 LotsOfEntries 600 pass
+ */
+
+import java.nio.file.*;
+import static java.nio.file.StandardWatchEventKinds.*;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+public class LotsOfEntries {
+
+    static void testCreateLotsOfEntries(Path dir, int numEvents, boolean fail) throws Exception {
+        try (WatchService watcher = FileSystems.getDefault().newWatchService()) {
+            System.out.format("register %s for events\n", dir);
+            WatchKey key = dir.register(watcher, ENTRY_CREATE);
+
+            System.out.format("create %d entries\n", numEvents);
+            Set<Path> entries = new HashSet<>();
+            for (int i = 0; i < numEvents; i++) {
+                Path entry = dir.resolve("entry" + i);
+                entries.add(entry);
+                Files.createFile(entry);
+            }
+
+            // Wait for all events to be signalled - the timeout is long to
+            // allow for polling implementations. Since we specifically want to
+            // test the maximum number of events buffered for a single
+            // WatchKey#pollEvents call, we need to poll on the WatchService
+            // repeatedly until all (not just some) events have been signalled.
+            System.out.println("poll watcher...");
+            WatchKey signalledKey;
+            do {
+              signalledKey = watcher.poll(10, TimeUnit.SECONDS);
+              if (signalledKey != null && signalledKey != key) {
+                throw new RuntimeException("Unexpected key returned from poll");
+              }
+            } while (signalledKey != null);
+
+            if (fail) {
+                System.out.println("poll expecting overflow...");
+                var events = key.pollEvents();
+                if (events.size() != 1) {
+                    throw new RuntimeException(
+                        "Expected overflow event, got: " + toString(events));
+                }
+                if (!events.getFirst().kind().equals(OVERFLOW)) {
+                    throw new RuntimeException(
+                        "Expected overflow event, got: " + toString(events));
+                }
+            } else {
+                System.out.println("poll not expecting overflow...");
+                List<WatchEvent<?>> events = key.pollEvents();
+                Set<Path> contexts = events.stream()
+                    .map(WatchEvent::context)
+                    .map(Path.class::cast)
+                    .map(entry -> dir.resolve(entry))
+                    .collect(Collectors.toSet());
+                if (!entries.equals(contexts)) {
+                    throw new RuntimeException(
+                        "Expected events on: " + entries + ", got: " + toString(events));
+                }
+            }
+        }
+    }
+
+    static String toString(List<WatchEvent<?>> events) {
+        return events.stream()
+            .map(LotsOfEntries::toString)
+            .collect(Collectors.joining(", "));
+    }
+
+    static String toString(WatchEvent event) {
+        return String.format("%s(%d): %s", event.kind(), event.count(), event.context());
+    }
+
+    public static void main(String[] args) throws Exception {
+        Path dir = TestUtil.createTemporaryDirectory();
+        int numEvents = Integer.parseInt(args[0]);
+        boolean fail = args[1].equals("fail");
+        try {
+            testCreateLotsOfEntries(dir, numEvents, fail);
+        } finally {
+            TestUtil.removeAll(dir);
+        }
+    }
+}