121 lines
5.1 KiB
Java
121 lines
5.1 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|