-1 (Please revert) On Sun, 15 Feb 2026 at 09:19, <[email protected]> wrote: > > This is an automated email from the ASF dual-hosted git repository. > > tibordigana pushed a commit to branch revert-3252-ppidchecker-processhandle > in repository https://gitbox.apache.org/repos/asf/maven-surefire.git > > commit b829dd4cad2bdcbd079747c5113ed6576109d4a5 > Author: Tibor Digana <[email protected]> > AuthorDate: Sun Feb 15 00:19:10 2026 +0100 > > Revert "Replace runing external process and parsing output with simple > Proces…" > > This reverts commit 0b190142a3df4cb3dda52825e7fedda59591cbc8. > --- > maven-surefire-common/pom.xml | 1 + > .../plugin/surefire/booterclient/Platform.java | 9 +- > .../src/site/apt/examples/shutdown.apt.vm | 6 +- > surefire-booter/pom.xml | 5 - > .../apache/maven/surefire/booter/ForkedBooter.java | 12 +- > .../apache/maven/surefire/booter/PpidChecker.java | 27 +- > .../maven/surefire/booter/ProcessChecker.java | 108 ------ > .../surefire/booter/ProcessHandleChecker.java | 238 ------------ > .../apache/maven/surefire/booter/ProcessInfo.java | 11 - > .../apache/maven/surefire/booter/SystemUtils.java | 1 - > .../maven/surefire/booter/PpidCheckerTest.java | 432 > +++++++++++++++++++++ > .../maven/surefire/booter/ProcessCheckerTest.java | 248 ------------ > .../surefire/booter/ProcessHandleCheckerTest.java | 205 ---------- > 13 files changed, 452 insertions(+), 851 deletions(-) > > diff --git a/maven-surefire-common/pom.xml b/maven-surefire-common/pom.xml > index 072efcabf..a9feb6dd9 100644 > --- a/maven-surefire-common/pom.xml > +++ b/maven-surefire-common/pom.xml > @@ -172,6 +172,7 @@ > <dependency> > <groupId>commons-io</groupId> > <artifactId>commons-io</artifactId> > + <version>2.21.0</version> > <scope>test</scope> > </dependency> > </dependencies> > diff --git > a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/booterclient/Platform.java > > b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/booterclient/Platform.java > index e18803142..12d19c5e8 100644 > --- > a/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/booterclient/Platform.java > +++ > b/maven-surefire-common/src/main/java/org/apache/maven/plugin/surefire/booterclient/Platform.java > @@ -29,7 +29,7 @@ > > /** > * Loads platform specifics. > - * TODO simplify or remove when Java 8 support is dropped > + * > * @author <a href="mailto:[email protected]";>Tibor Digana (tibor17)</a> > * @since 2.20.1 > */ > @@ -80,6 +80,11 @@ public Platform > withJdkExecAttributesForTests(JdkAttributes jdk) { > } > > private static Callable<Long> pidJob() { > - return SystemUtils::pid; > + return new Callable<Long>() { > + @Override > + public Long call() throws Exception { > + return SystemUtils.pid(); > + } > + }; > } > } > diff --git a/maven-surefire-plugin/src/site/apt/examples/shutdown.apt.vm > b/maven-surefire-plugin/src/site/apt/examples/shutdown.apt.vm > index 93083858d..92f9ddc6c 100644 > --- a/maven-surefire-plugin/src/site/apt/examples/shutdown.apt.vm > +++ b/maven-surefire-plugin/src/site/apt/examples/shutdown.apt.vm > @@ -55,13 +55,9 @@ Shutdown of Forked JVM > > [] > > - If Java9 is available, the start time of the process is determined by <<< > ProcessHandle.current().info().startInstant() >>>. > - > On Unix like systems the process' uptime is determined by native command > <<< (/usr)/bin/ps -o etime= -p [PID] >>>. > > - On Windows the start time is determined using <<< powershell -command > "... Get-CimInstance Win32_Process ..." >>>. > - > - [] > + On Windows the start time is determined using <<< wmic process where > (ProcessId=[PID]) get CreationDate >>> > in the forked JVM. > > > diff --git a/surefire-booter/pom.xml b/surefire-booter/pom.xml > index 74b055a9d..c24bb7e36 100644 > --- a/surefire-booter/pom.xml > +++ b/surefire-booter/pom.xml > @@ -91,11 +91,6 @@ > <artifactId>powermock-api-mockito2</artifactId> > <scope>test</scope> > </dependency> > - <dependency> > - <groupId>commons-io</groupId> > - <artifactId>commons-io</artifactId> > - <scope>test</scope> > - </dependency> > </dependencies> > > <build> > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ForkedBooter.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ForkedBooter.java > index 5067509c3..1bcdc8b09 100644 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ForkedBooter.java > +++ > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ForkedBooter.java > @@ -215,7 +215,7 @@ private void closeForkChannel() { > } > > private PingScheduler listenToShutdownCommands(String ppid) { > - ProcessChecker ppidChecker = ProcessChecker.of(ppid); > + PpidChecker ppidChecker = ppid == null ? null : new > PpidChecker(ppid); > commandReader.addShutdownListener(createExitHandler(ppidChecker)); > AtomicBoolean pingDone = new AtomicBoolean(true); > commandReader.addNoopListener(createPingHandler(pingDone)); > @@ -280,7 +280,7 @@ public void update(Command command) { > }; > } > > - private CommandListener createExitHandler(final ProcessChecker > ppidChecker) { > + private CommandListener createExitHandler(final PpidChecker ppidChecker) > { > return new CommandListener() { > @Override > public void update(Command command) { > @@ -325,7 +325,7 @@ public void update(Command command) { > }; > } > > - private Runnable createPingJob(final AtomicBoolean pingDone, final > ProcessChecker pluginProcessChecker) { > + private Runnable createPingJob(final AtomicBoolean pingDone, final > PpidChecker pluginProcessChecker) { > return new Runnable() { > @Override > public void run() { > @@ -515,7 +515,7 @@ private static void run(ForkedBooter booter, String[] > args) { > } > } > > - private static boolean canUseNewPingMechanism(ProcessChecker > pluginProcessChecker) { > + private static boolean canUseNewPingMechanism(PpidChecker > pluginProcessChecker) { > return pluginProcessChecker != null && pluginProcessChecker.canUse(); > } > > @@ -553,12 +553,12 @@ private static boolean isDebugging() { > private static class PingScheduler { > private final ScheduledExecutorService pingScheduler; > private final ScheduledExecutorService processCheckerScheduler; > - private final ProcessChecker processChecker; > + private final PpidChecker processChecker; > > PingScheduler( > ScheduledExecutorService pingScheduler, > ScheduledExecutorService processCheckerScheduler, > - ProcessChecker processChecker) { > + PpidChecker processChecker) { > this.pingScheduler = pingScheduler; > this.processCheckerScheduler = processCheckerScheduler; > this.processChecker = processChecker; > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/PpidChecker.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/PpidChecker.java > index bfcc70d18..b8891e822 100644 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/PpidChecker.java > +++ > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/PpidChecker.java > @@ -57,18 +57,11 @@ > > /** > * Recognizes PID of Plugin process and determines lifetime. > - * <p> > - * This implementation uses native commands ({@code ps} on Unix, {@code > powershell} on Windows) > - * to check the parent process status. On Java 9+, consider using {@code > ProcessHandleChecker} > - * instead, which uses the Java {@code ProcessHandle} API and doesn't > require spawning external processes. > * > * @author <a href="mailto:[email protected]";>Tibor Digana (tibor17)</a> > * @since 2.20.1 > - * @see ProcessChecker > - * @deprecated Use {@code ProcessHandleChecker} via {@link > ProcessChecker#of(String)} instead > */ > -@Deprecated > -final class PpidChecker implements ProcessChecker { > +final class PpidChecker { > private static final long MINUTES_TO_MILLIS = 60L * 1000L; > // 25 chars > https://superuser.com/questions/937380/get-creation-time-of-file-in-milliseconds/937401#937401 > private static final int WMIC_CREATION_DATE_VALUE_LENGTH = 25; > @@ -102,8 +95,7 @@ final class PpidChecker implements ProcessChecker { > this.ppid = ppid; > } > > - @Override > - public boolean canUse() { > + boolean canUse() { > if (isStopped()) { > return false; > } > @@ -119,8 +111,7 @@ public boolean canUse() { > * or this object has been {@link > #destroyActiveCommands() destroyed} > * @throws NullPointerException if extracted e-time is null > */ > - @Override > - public boolean isProcessAlive() { > + boolean isProcessAlive() { > if (!canUse()) { > throw new IllegalStateException("irrelevant to call > isProcessAlive()"); > } > @@ -235,16 +226,14 @@ ProcessInfo consumeLine(String line, ProcessInfo > previousProcessInfo) throws Exc > return reader.execute(psPath + "powershell", "-NoProfile", > "-NonInteractive", "-Command", psCommand); > } > > - @Override > - public void destroyActiveCommands() { > + void destroyActiveCommands() { > stopped = true; > for (Process p = destroyableCommands.poll(); p != null; p = > destroyableCommands.poll()) { > p.destroy(); > } > } > > - @Override > - public boolean isStopped() { > + boolean isStopped() { > return stopped; > } > > @@ -336,16 +325,10 @@ private static SimpleDateFormat > createWindowsCreationDateFormat() { > return formatter; > } > > - @Override > public void stop() { > stopped = true; > } > > - @Override > - public ProcessInfo processInfo() { > - return parentProcessInfo; > - } > - > /** > * Reads standard output from {@link Process}. > * <br> > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessChecker.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessChecker.java > deleted file mode 100644 > index ef495eb53..000000000 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessChecker.java > +++ /dev/null > @@ -1,108 +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.maven.surefire.booter; > - > -/** > - * Interface for checking if a process (typically the parent Maven plugin) > is still alive. > - * <p> > - * Implementations allow the forked JVM to detect when its parent Maven > process > - * has terminated, enabling cleanup and preventing orphaned processes. > - * > - * @since 3.5.5 > - */ > -public interface ProcessChecker { > - > - /** > - * Creates the appropriate {@link ProcessChecker} implementation for the > given parent PID. > - * <p> > - * On Java 9+, uses {@code ProcessHandleChecker} which leverages the > {@code ProcessHandle} API. > - * On Java 8, falls back to {@link PpidChecker} which uses native > commands. > - * > - * @param ppid the parent process ID as a string, or {@code null} > - * @return a new checker instance, or {@code null} if ppid is {@code > null} > - */ > - static ProcessChecker of(String ppid) { > - if (ppid == null) { > - return null; > - } > - if (ProcessHandleChecker.isAvailable()) { > - return new ProcessHandleChecker(ppid); > - } > - return new PpidChecker(ppid); > - } > - > - /** > - * Returns whether the ProcessHandle API is available in the current JVM. > - * > - * @return {@code true} if running on Java 9+ with ProcessHandle > available > - */ > - static boolean isProcessHandleSupported() { > - return ProcessHandleChecker.isAvailable(); > - } > - > - /** > - * Checks whether this checker can be used to monitor the process. > - * <p> > - * This method must return {@code true} before {@link #isProcessAlive()} > can be called. > - * @deprecated with using ProcessHandleChecker on Java 9+, this method > will always return {@code true} and can be removed in a future release. > - * @return {@code true} if the checker is operational and can monitor > the process > - */ > - @Deprecated > - boolean canUse(); > - > - /** > - * Checks if the process is still alive. > - * <p> > - * This method can only be called after {@link #canUse()} has returned > {@code true}. > - * > - * @return {@code true} if the process is still running; {@code false} > if it has terminated > - * or if the PID has been reused by a different process > - * @throws IllegalStateException if {@link #canUse()} returns {@code > false} or if the checker > - * has been stopped > - */ > - boolean isProcessAlive(); > - > - /** > - * Stops the checker and releases any resources. > - * <p> > - * After calling this method, {@link #canUse()} will return {@code > false}. > - */ > - void stop(); > - > - /** > - * Destroys any active commands or subprocesses used by this checker. > - * <p> > - * This is called during shutdown to ensure clean termination. > - */ > - void destroyActiveCommands(); > - > - /** > - * Checks if the checker has been stopped. > - * > - * @return {@code true} if {@link #stop()} or {@link > #destroyActiveCommands()} has been called > - */ > - boolean isStopped(); > - > - /** > - * Returns information about the process being checked. > - * > - * @return the process information, or {@code null} if not yet > initialized > - */ > - ProcessInfo processInfo(); > -} > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessHandleChecker.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessHandleChecker.java > deleted file mode 100644 > index a97e6ace4..000000000 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessHandleChecker.java > +++ /dev/null > @@ -1,238 +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.maven.surefire.booter; > - > -import javax.annotation.Nonnull; > - > -import java.lang.reflect.Method; > -import java.util.Optional; > - > -import static > org.apache.maven.surefire.api.util.ReflectionUtils.invokeMethodWithArray; > -import static > org.apache.maven.surefire.api.util.ReflectionUtils.tryGetMethod; > -import static > org.apache.maven.surefire.api.util.ReflectionUtils.tryLoadClass; > - > -/** > - * Checks if a process is alive using the ProcessHandle API via reflection. > - * <p> > - * This implementation uses reflection to access the Java 9+ {@code > ProcessHandle} API, > - * allowing the class to compile on Java 8 while functioning on Java 9+. > - * <p> > - * The checker detects two scenarios indicating the process is no longer > available: > - * <ol> > - * <li>The process has terminated ({@code ProcessHandle.isAlive()} returns > {@code false})</li> > - * <li>The PID has been reused by the OS for a new process (start time > differs from initial)</li> > - * </ol> > - * > - * @since 3.5.5 > - */ > -final class ProcessHandleChecker implements ProcessChecker { > - > - /** Whether ProcessHandle API is available and reflection setup > succeeded */ > - private static final boolean AVAILABLE; > - > - // Method references for ProcessHandle > - private static final Method PROCESS_HANDLE_OF; // ProcessHandle.of(long) > -> Optional<ProcessHandle> > - private static final Method PROCESS_HANDLE_IS_ALIVE; // > ProcessHandle.isAlive() -> boolean > - private static final Method PROCESS_HANDLE_INFO; // ProcessHandle.info() > -> ProcessHandle.Info > - > - // Method references for ProcessHandle.Info > - private static final Method INFO_START_INSTANT; // > ProcessHandle.Info.startInstant() -> Optional<Instant> > - > - // Method reference for Instant > - private static final Method INSTANT_TO_EPOCH_MILLI; // > Instant.toEpochMilli() -> long > - > - static { > - ClassLoader classLoader = > Thread.currentThread().getContextClassLoader(); > - > - // Load classes using ReflectionUtils > - Class<?> processHandleClass = tryLoadClass(classLoader, > "java.lang.ProcessHandle"); > - Class<?> processHandleInfoClass = tryLoadClass(classLoader, > "java.lang.ProcessHandle$Info"); > - Class<?> optionalClass = tryLoadClass(classLoader, > "java.util.Optional"); > - Class<?> instantClass = tryLoadClass(classLoader, > "java.time.Instant"); > - > - Method processHandleOf = null; > - Method processHandleIsAlive = null; > - Method processHandleInfo = null; > - Method infoStartInstant = null; > - Method optionalIsPresent = null; > - Method optionalGet = null; > - Method optionalOrElse = null; > - Method instantToEpochMilli = null; > - > - if (processHandleClass != null && processHandleInfoClass != null && > optionalClass != null) { > - // ProcessHandle methods > - processHandleOf = tryGetMethod(processHandleClass, "of", > long.class); > - processHandleIsAlive = tryGetMethod(processHandleClass, > "isAlive"); > - processHandleInfo = tryGetMethod(processHandleClass, "info"); > - > - // ProcessHandle.Info methods > - infoStartInstant = tryGetMethod(processHandleInfoClass, > "startInstant"); > - > - // Optional methods > - optionalIsPresent = tryGetMethod(optionalClass, "isPresent"); > - optionalGet = tryGetMethod(optionalClass, "get"); > - optionalOrElse = tryGetMethod(optionalClass, "orElse", > Object.class); > - > - // Instant methods (for processInfo) > - if (instantClass != null) { > - instantToEpochMilli = tryGetMethod(instantClass, > "toEpochMilli"); > - } > - } > - > - // All methods must be available for ProcessHandle API to be usable > - AVAILABLE = processHandleOf != null > - && processHandleIsAlive != null > - && processHandleInfo != null > - && infoStartInstant != null > - && optionalIsPresent != null > - && optionalGet != null > - && optionalOrElse != null; > - > - PROCESS_HANDLE_OF = processHandleOf; > - PROCESS_HANDLE_IS_ALIVE = processHandleIsAlive; > - PROCESS_HANDLE_INFO = processHandleInfo; > - INFO_START_INSTANT = infoStartInstant; > - INSTANT_TO_EPOCH_MILLI = instantToEpochMilli; > - } > - > - private final long pid; > - private final Object processHandle; // ProcessHandle (stored as Object) > - private volatile Object initialStartInstant; // Instant (stored as > Object) > - private volatile boolean stopped; > - > - /** > - * Creates a new checker for the given process ID. > - * > - * @param pid the process ID as a string > - * @throws NumberFormatException if pid is not a valid long > - */ > - ProcessHandleChecker(@Nonnull String pid) { > - this.pid = Long.parseLong(pid); > - try { > - Optional<?> optionalObject = (Optional<?>) > PROCESS_HANDLE_OF.invoke(null, this.pid); > - processHandle = optionalObject.orElse(null); > - initialStartInstant = getInitialStartInstant(); > - } catch (Exception e) { > - throw new IllegalStateException("Failed to initialize > ProcessHandleChecker for PID " + pid, e); > - } > - } > - > - /** > - * Returns whether the ProcessHandle API is available for use. > - * This is a static check that can be used by the factory. > - * > - * @return true if ProcessHandle API is available (Java 9+) > - */ > - static boolean isAvailable() { > - return AVAILABLE; > - } > - > - @Override > - public boolean canUse() { > - return (AVAILABLE && !stopped); > - } > - > - /** > - * {@inheritDoc} > - * <p> > - * This implementation checks both that the process is alive and that > it's the same process > - * that was originally identified (by comparing start times to detect > PID reuse). > - */ > - @Override > - public boolean isProcessAlive() { > - if (!canUse()) { > - throw new IllegalStateException("irrelevant to call > isProcessAlive()"); > - } > - > - try { > - // Check if process is still running: processHandle.isAlive() > - boolean isAlive = invokeMethodWithArray(processHandle, > PROCESS_HANDLE_IS_ALIVE); > - if (!isAlive) { > - return false; > - } > - > - // Verify it's the same process (not a reused PID) > - if (initialStartInstant != null) { > - // processHandle.info().startInstant() > - Object info = invokeMethodWithArray(processHandle, > PROCESS_HANDLE_INFO); > - Optional<?> optionalInstant = invokeMethodWithArray(info, > INFO_START_INSTANT); > - > - if (optionalInstant.isPresent()) { > - Object currentStartInstant = optionalInstant.get(); > - // PID was reused for a different process > - return currentStartInstant.equals(initialStartInstant); > - } > - } > - > - return true; > - } catch (RuntimeException e) { > - // Reflection failed during runtime - treat as process not alive > - return false; > - } > - } > - > - private Object getInitialStartInstant() { > - try { > - Object info = invokeMethodWithArray(processHandle, > PROCESS_HANDLE_INFO); > - Optional<?> optionalInstant = invokeMethodWithArray(info, > INFO_START_INSTANT); > - return optionalInstant.orElse(null); > - } catch (RuntimeException e) { > - return null; > - } > - } > - > - @Override > - public void destroyActiveCommands() { > - stopped = true; > - // No subprocess to destroy - ProcessHandle doesn't spawn processes > - } > - > - @Override > - public boolean isStopped() { > - return stopped; > - } > - > - @Override > - public void stop() { > - stopped = true; > - } > - > - @Override > - public ProcessInfo processInfo() { > - Object startInstant = getInitialStartInstant(); > - if (startInstant == null || INSTANT_TO_EPOCH_MILLI == null) { > - return null; > - } > - try { > - long startTimeMillis = invokeMethodWithArray(startInstant, > INSTANT_TO_EPOCH_MILLI); > - return ProcessInfo.processHandleInfo(String.valueOf(pid), > startTimeMillis); > - } catch (RuntimeException e) { > - return null; > - } > - } > - > - @Override > - public String toString() { > - String args = "pid=" + pid + ", stopped=" + stopped + ", hasHandle=" > + (processHandle != null); > - if (initialStartInstant != null) { > - args += ", startInstant=" + initialStartInstant; > - } > - return "ProcessHandleChecker{" + args + "}"; > - } > -} > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessInfo.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessInfo.java > index 630c7dd5b..771445965 100644 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessInfo.java > +++ > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/ProcessInfo.java > @@ -48,17 +48,6 @@ final class ProcessInfo { > return new ProcessInfo(pid, startTimestamp); > } > > - /** > - * Creates process info from ProcessHandle API data. > - * > - * @param pid the process ID > - * @param startTimeMillis the process start time in epoch milliseconds > - * @return a new ProcessInfo instance > - */ > - static @Nonnull ProcessInfo processHandleInfo(String pid, long > startTimeMillis) { > - return new ProcessInfo(pid, startTimeMillis); > - } > - > private final String pid; > private final long time; > > diff --git > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/SystemUtils.java > > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/SystemUtils.java > index 35f5cf75e..3f7b4aa5b 100644 > --- > a/surefire-booter/src/main/java/org/apache/maven/surefire/booter/SystemUtils.java > +++ > b/surefire-booter/src/main/java/org/apache/maven/surefire/booter/SystemUtils.java > @@ -172,7 +172,6 @@ public static ClassLoader platformClassLoader() { > return null; > } > > - // TODO simplify or remove when Java 8 support is dropped > public static Long pid() { > if (isBuiltInJava9AtLeast()) { > Long pid = pidOnJava9(); > diff --git > a/surefire-booter/src/test/java/org/apache/maven/surefire/booter/PpidCheckerTest.java > > b/surefire-booter/src/test/java/org/apache/maven/surefire/booter/PpidCheckerTest.java > new file mode 100644 > index 000000000..5b05d1a46 > --- /dev/null > +++ > b/surefire-booter/src/test/java/org/apache/maven/surefire/booter/PpidCheckerTest.java > @@ -0,0 +1,432 @@ > +/* > + * 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.maven.surefire.booter; > + > +import javax.annotation.Nonnull; > + > +import java.io.File; > +import java.io.IOException; > +import java.io.InterruptedIOException; > +import java.lang.management.ManagementFactory; > +import java.util.Random; > +import java.util.regex.Matcher; > + > +import org.apache.maven.surefire.api.booter.DumpErrorSingleton; > +import org.junit.After; > +import org.junit.Before; > +import org.junit.Rule; > +import org.junit.Test; > +import org.junit.rules.ExpectedException; > +import org.junit.rules.TemporaryFolder; > + > +import static java.nio.charset.StandardCharsets.US_ASCII; > +import static java.nio.file.Files.readAllBytes; > +import static java.util.concurrent.TimeUnit.SECONDS; > +import static org.apache.maven.surefire.booter.ProcessInfo.unixProcessInfo; > +import static > org.apache.maven.surefire.booter.ProcessInfo.windowsProcessInfo; > +import static org.apache.maven.surefire.shared.lang3.SystemUtils.IS_OS_UNIX; > +import static > org.apache.maven.surefire.shared.lang3.SystemUtils.IS_OS_WINDOWS; > +import static org.assertj.core.api.Assertions.assertThat; > +import static org.hamcrest.CoreMatchers.is; > +import static org.hamcrest.CoreMatchers.not; > +import static org.hamcrest.CoreMatchers.notNullValue; > +import static org.junit.Assert.fail; > +import static org.junit.Assume.assumeThat; > +import static org.junit.Assume.assumeTrue; > +import static org.powermock.reflect.Whitebox.invokeMethod; > +import static org.powermock.reflect.Whitebox.setInternalState; > + > +/** > + * Testing {@link PpidChecker} on a platform. > + * > + * @author <a href="mailto:[email protected]";>Tibor Digana (tibor17)</a> > + * @since 2.20.1 > + */ > +@SuppressWarnings("checkstyle:magicnumber") > +public class PpidCheckerTest { > + private static final Random RND = new Random(); > + > + @Rule > + public final ExpectedException exceptions = ExpectedException.none(); > + > + @Rule > + public final TemporaryFolder tempFolder = new TemporaryFolder(); > + > + private File reportsDir; > + private String dumpFileName; > + > + @Before > + public void initTmpFile() { > + reportsDir = tempFolder.getRoot(); > + dumpFileName = "surefire-" + RND.nextLong(); > + } > + > + @After > + public void deleteTmpFiles() { > + tempFolder.delete(); > + } > + > + @Test > + public void canExecuteUnixPs() { > + assumeTrue(IS_OS_UNIX); > + assertThat(PpidChecker.canExecuteUnixPs()) > + .as("Surefire should be tested on real box OS, e.g. Ubuntu > or FreeBSD.") > + .isTrue(); > + } > + > + @Test > + public void shouldHavePidAtBegin() { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + ProcessInfo processInfo = IS_OS_UNIX ? checker.unix() : > checker.windows(); > + > + assertThat(processInfo).isNotNull(); > + > + assertThat(checker.canUse()).isTrue(); > + > + assertThat(checker.isProcessAlive()).isTrue(); > + > + assertThat(processInfo.getPID()).isEqualTo(expectedPid); > + > + assertThat(processInfo.getTime()).isGreaterThan(0L); > + } > + > + @Test > + public void shouldHavePid() throws Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + setInternalState( > + checker, > + "parentProcessInfo", > + IS_OS_UNIX > + ? unixProcessInfo(expectedPid, 0L) > + : windowsProcessInfo(expectedPid, > windowsProcessStartTime(checker))); > + > + // the etime in Unix is measured in seconds. So let's wait 1 s at > least. > + SECONDS.sleep(1L); > + > + ProcessInfo processInfo = IS_OS_UNIX ? checker.unix() : > checker.windows(); > + > + assertThat(processInfo).isNotNull(); > + > + assertThat(checker.canUse()).isTrue(); > + > + assertThat(checker.isProcessAlive()).isTrue(); > + > + assertThat(processInfo.getPID()).isEqualTo(expectedPid); > + > + assertThat(processInfo.getTime()).isGreaterThan(0L); > + > + assertThat(checker.toString()) > + .contains("ppid=" + expectedPid) > + .contains("stopped=false") > + .contains("invalid=false") > + .contains("error=false"); > + > + checker.destroyActiveCommands(); > + assertThat(checker.canUse()).isFalse(); > + assertThat((boolean) invokeMethod(checker, "isStopped")).isTrue(); > + } > + > + @Test > + public void shouldBeStopped() { > + PpidChecker checker = new PpidChecker("0"); > + checker.stop(); > + > + assertThat(checker.canUse()).isFalse(); > + > + exceptions.expect(IllegalStateException.class); > + exceptions.expectMessage("irrelevant to call isProcessAlive()"); > + > + checker.isProcessAlive(); > + > + fail("this test should throw exception"); > + } > + > + @Test > + public void shouldBeStoppedCheckerWithError() throws Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + checker.stop(); > + > + ProcessInfo processInfo = IS_OS_UNIX ? checker.unix() : > checker.windows(); > + assertThat(processInfo.isError()).isTrue(); > + > + String error = new String(readAllBytes(new File(reportsDir, > dumpFileName + ".dump").toPath())); > + > + assertThat(error).contains("<<exit>> <<0>>").contains("<<stopped>> > <<true>>"); > + } > + > + @Test > + public void shouldBeEmptyDump() throws Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + > + try { > + Thread.currentThread().interrupt(); > + > + ProcessInfo processInfo = IS_OS_UNIX ? checker.unix() : > checker.windows(); > + //noinspection ResultOfMethodCallIgnored > + Thread.interrupted(); > + assertThat(processInfo.isError()).isTrue(); > + > + File dumpFile = new File(reportsDir, dumpFileName + ".dump"); > + if (dumpFile.exists()) { > + String error = new String(readAllBytes(dumpFile.toPath())); > + > + assertThat(error).contains("<<exit>>").contains("<<stopped>> > <<false>>"); > + } > + } finally { > + //noinspection ResultOfMethodCallIgnored > + Thread.interrupted(); > + } > + } > + > + @Test > + public void shouldStartedProcessThrowInterruptedException() throws > Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + > + PpidChecker.ProcessInfoConsumer consumer = checker.new > ProcessInfoConsumer(US_ASCII.name()) { > + @Nonnull > + @Override > + ProcessInfo consumeLine(String line, ProcessInfo > previousProcessInfo) throws Exception { > + throw new InterruptedException(); > + } > + }; > + > + String[] cmd = > + IS_OS_WINDOWS ? new String[] {"CMD", "/A", "/X", "/C", > "dir"} : new String[] {"/bin/sh", "-c", "ls"}; > + > + assertThat(consumer.execute(cmd).isError()).isTrue(); > + assertThat(new File(reportsDir, dumpFileName + > ".dump")).doesNotExist(); > + } > + > + @Test > + public void shouldStartedProcessThrowInterruptedIOException() throws > Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + > + PpidChecker.ProcessInfoConsumer consumer = checker.new > ProcessInfoConsumer(US_ASCII.name()) { > + @Nonnull > + @Override > + ProcessInfo consumeLine(String line, ProcessInfo > previousProcessInfo) throws Exception { > + throw new InterruptedIOException(); > + } > + }; > + > + String[] cmd = > + IS_OS_WINDOWS ? new String[] {"CMD", "/A", "/X", "/C", > "dir"} : new String[] {"/bin/sh", "-c", "ls"}; > + > + assertThat(consumer.execute(cmd).isError()).isTrue(); > + assertThat(new File(reportsDir, dumpFileName + > ".dump")).doesNotExist(); > + } > + > + @Test > + public void shouldStartedProcessThrowIOException() throws Exception { > + String expectedPid = > + > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > + DumpErrorSingleton.getSingleton().init(reportsDir, dumpFileName); > + > + PpidChecker checker = new PpidChecker(expectedPid); > + > + PpidChecker.ProcessInfoConsumer consumer = checker.new > ProcessInfoConsumer(US_ASCII.name()) { > + @Nonnull > + @Override > + ProcessInfo consumeLine(String line, ProcessInfo > previousProcessInfo) throws Exception { > + throw new IOException("wrong command"); > + } > + }; > + > + String[] cmd = > + IS_OS_WINDOWS ? new String[] {"CMD", "/A", "/X", "/C", > "dir"} : new String[] {"/bin/sh", "-c", "ls"}; > + > + assertThat(consumer.execute(cmd).isError()).isTrue(); > + > + File dumpFile = new File(reportsDir, dumpFileName + ".dump"); > + > + String error = new String(readAllBytes(dumpFile.toPath())); > + > + > assertThat(error).contains(IOException.class.getName()).contains("wrong > command"); > + } > + > + @Test > + public void shouldNotFindSuchPID() { > + PpidChecker checker = new PpidChecker("1000000"); > + setInternalState(checker, "parentProcessInfo", > ProcessInfo.ERR_PROCESS_INFO); > + > + assertThat(checker.canUse()).isFalse(); > + > + exceptions.expect(IllegalStateException.class); > + exceptions.expectMessage("irrelevant to call isProcessAlive()"); > + > + checker.isProcessAlive(); > + > + fail("this test should throw exception"); > + } > + > + @Test > + public void shouldNotBeAlive() { > + PpidChecker checker = new PpidChecker("1000000"); > + > + assertThat(checker.canUse()).isTrue(); > + > + assertThat(checker.isProcessAlive()).isFalse(); > + } > + > + @Test > + public void shouldParseEtime() { > + Matcher m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("38 > 1234567890"); > + assertThat(m.matches()).isFalse(); > + > + m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("05:38 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromDays(m)).isEqualTo(0L); > + assertThat(PpidChecker.fromHours(m)).isEqualTo(0L); > + assertThat(PpidChecker.fromMinutes(m)).isEqualTo(300L); > + assertThat(PpidChecker.fromSeconds(m)).isEqualTo(38L); > + assertThat(PpidChecker.fromPID(m)).isEqualTo("1234567890"); > + > + m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("00:05:38 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromDays(m)).isEqualTo(0L); > + assertThat(PpidChecker.fromHours(m)).isEqualTo(0L); > + assertThat(PpidChecker.fromMinutes(m)).isEqualTo(300L); > + assertThat(PpidChecker.fromSeconds(m)).isEqualTo(38L); > + assertThat(PpidChecker.fromPID(m)).isEqualTo("1234567890"); > + > + m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("01:05:38 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromDays(m)).isEqualTo(0L); > + assertThat(PpidChecker.fromHours(m)).isEqualTo(3600L); > + assertThat(PpidChecker.fromMinutes(m)).isEqualTo(300L); > + assertThat(PpidChecker.fromSeconds(m)).isEqualTo(38L); > + assertThat(PpidChecker.fromPID(m)).isEqualTo("1234567890"); > + > + m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("02-01:05:38 > 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromDays(m)).isEqualTo(2 * 24 * 3600L); > + assertThat(PpidChecker.fromHours(m)).isEqualTo(3600L); > + assertThat(PpidChecker.fromMinutes(m)).isEqualTo(300L); > + assertThat(PpidChecker.fromSeconds(m)).isEqualTo(38L); > + assertThat(PpidChecker.fromPID(m)).isEqualTo("1234567890"); > + > + m = PpidChecker.UNIX_CMD_OUT_PATTERN.matcher("02-1:5:3 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromDays(m)).isEqualTo(2 * 24 * 3600L); > + assertThat(PpidChecker.fromHours(m)).isEqualTo(3600L); > + assertThat(PpidChecker.fromMinutes(m)).isEqualTo(300L); > + assertThat(PpidChecker.fromSeconds(m)).isEqualTo(3L); > + assertThat(PpidChecker.fromPID(m)).isEqualTo("1234567890"); > + } > + > + @Test > + public void shouldParseBusyboxHoursEtime() { > + Matcher m = PpidChecker.BUSYBOX_CMD_OUT_PATTERN.matcher("38 > 1234567890"); > + assertThat(m.matches()).isFalse(); > + > + m = PpidChecker.BUSYBOX_CMD_OUT_PATTERN.matcher("05h38 1234567890"); > + assertThat(m.matches()).isTrue(); > + assertThat(PpidChecker.fromBusyboxHours(m)).isEqualTo(3600 * 5L); > + assertThat(PpidChecker.fromBusyboxMinutes(m)).isEqualTo(60 * 38L); > + assertThat(PpidChecker.fromBusyboxPID(m)).isEqualTo("1234567890"); > + } > + > + @Test > + public void shouldHaveSystemPathToPowerShellOnWindows() throws Exception > { > + assumeTrue(IS_OS_WINDOWS); > + assumeThat(System.getenv("SystemRoot"), is(notNullValue())); > + assumeThat(System.getenv("SystemRoot"), is(not(""))); > + assumeTrue(new File(System.getenv("SystemRoot"), > "System32\\WindowsPowerShell\\v1.0").isDirectory()); > + assumeTrue(new File(System.getenv("SystemRoot"), > "System32\\WindowsPowerShell\\v1.0\\powershell.exe").isFile()); > + assertThat((Boolean) invokeMethod(PpidChecker.class, > "hasPowerShellStandardSystemPath")) > + .isTrue(); > + assertThat(new File(System.getenv("SystemRoot"), > "System32\\WindowsPowerShell\\v1.0\\powershell.exe")) > + .isFile(); > + } > + > + @Test > + public void shouldBeTypeNull() { > + assertThat(ProcessCheckerType.toEnum(null)).isNull(); > + > + assertThat(ProcessCheckerType.toEnum(" ")).isNull(); > + > + assertThat(ProcessCheckerType.isValid(null)).isTrue(); > + } > + > + @Test > + public void shouldBeException() { > + exceptions.expect(IllegalArgumentException.class); > + exceptions.expectMessage("unknown process checker"); > + > + assertThat(ProcessCheckerType.toEnum("anything else")).isNull(); > + } > + > + @Test > + public void shouldNotBeValid() { > + assertThat(ProcessCheckerType.isValid("anything")).isFalse(); > + } > + > + @Test > + public void shouldBeTypePing() { > + > assertThat(ProcessCheckerType.toEnum("ping")).isEqualTo(ProcessCheckerType.PING); > + > + assertThat(ProcessCheckerType.isValid("ping")).isTrue(); > + > + assertThat(ProcessCheckerType.PING.getType()).isEqualTo("ping"); > + } > + > + @Test > + public void shouldBeTypeNative() { > + > assertThat(ProcessCheckerType.toEnum("native")).isEqualTo(ProcessCheckerType.NATIVE); > + > + assertThat(ProcessCheckerType.isValid("native")).isTrue(); > + > + assertThat(ProcessCheckerType.NATIVE.getType()).isEqualTo("native"); > + } > + > + @Test > + public void shouldBeTypeAll() { > + > assertThat(ProcessCheckerType.toEnum("all")).isEqualTo(ProcessCheckerType.ALL); > + > + assertThat(ProcessCheckerType.isValid("all")).isTrue(); > + > + assertThat(ProcessCheckerType.ALL.getType()).isEqualTo("all"); > + } > + > + private static long windowsProcessStartTime(PpidChecker checker) { > + return checker.windows().getTime(); > + } > +} > diff --git > a/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessCheckerTest.java > > b/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessCheckerTest.java > deleted file mode 100644 > index ac5883d17..000000000 > --- > a/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessCheckerTest.java > +++ /dev/null > @@ -1,248 +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.maven.surefire.booter; > - > -import java.lang.management.ManagementFactory; > - > -import org.junit.Assume; > -import org.junit.Rule; > -import org.junit.Test; > -import org.junit.rules.ExpectedException; > - > -import static org.assertj.core.api.Assertions.assertThat; > -import static org.assertj.core.api.Assertions.assertThatThrownBy; > -import static org.junit.Assert.fail; > - > -/** > - * Testing {@link ProcessChecker} via {@link ProcessChecker#of(String)}. > - * > - * @since 2.20.1 > - */ > -@SuppressWarnings("checkstyle:magicnumber") > -public class ProcessCheckerTest { > - > - @Rule > - public final ExpectedException exceptions = ExpectedException.none(); > - > - @Test > - public void shouldHavePidAtBegin() { > - String expectedPid = > - > ManagementFactory.getRuntimeMXBean().getName().split("@")[0].trim(); > - > - ProcessChecker checker = ProcessChecker.of(expectedPid); > - > - assertThat(checker).isNotNull(); > - > - assertThat(checker.canUse()).isTrue(); > - > - assertThat(checker.isProcessAlive()).isTrue(); > - > - ProcessInfo processInfo = checker.processInfo(); > - assertThat(processInfo).isNotNull(); > - assertThat(processInfo.getPID()).isEqualTo(expectedPid); > - assertThat(processInfo.getTime()).isGreaterThan(0L); > - } > - > - @Test > - public void shouldBeStopped() { > - ProcessChecker checker = ProcessChecker.of("0"); > - checker.stop(); > - > - assertThat(checker.canUse()).isFalse(); > - > - exceptions.expect(IllegalStateException.class); > - exceptions.expectMessage("irrelevant to call isProcessAlive()"); > - > - checker.isProcessAlive(); > - > - fail("this test should throw exception"); > - } > - > - @Test > - public void exceptionCallIsProcessAlive() { > - // FIXME DisabledOnJre when we migrate to junit5 and run on unix too > - // winddows java 8 must depends on wwmc something available > - double v = > Double.parseDouble(System.getProperty("java.specification.version")); > - Assume.assumeTrue(v >= 9.0); > - ProcessChecker checker = > ProcessChecker.of(Long.toString(Integer.MAX_VALUE)); > - checker.stop(); > - > assertThatThrownBy(checker::isProcessAlive).isInstanceOf(IllegalStateException.class); > - } > - > - @Test > - public void shouldReturnNullForNullPpid() { > - ProcessChecker checker = ProcessChecker.of(null); > - assertThat(checker).isNull(); > - } > - > - @Test > - public void shouldBeTypeNull() { > - assertThat(ProcessCheckerType.toEnum(null)).isNull(); > - > - assertThat(ProcessCheckerType.toEnum(" ")).isNull(); > - > - assertThat(ProcessCheckerType.isValid(null)).isTrue(); > - } > - > - @Test > - public void shouldBeException() { > - exceptions.expect(IllegalArgumentException.class); > - exceptions.expectMessage("unknown process checker"); > - > - assertThat(ProcessCheckerType.toEnum("anything else")).isNull(); > - } > - > - @Test > - public void shouldNotBeValid() { > - assertThat(ProcessCheckerType.isValid("anything")).isFalse(); > - } > - > - @Test > - public void shouldBeTypePing() { > - > assertThat(ProcessCheckerType.toEnum("ping")).isEqualTo(ProcessCheckerType.PING); > - > - assertThat(ProcessCheckerType.isValid("ping")).isTrue(); > - > - assertThat(ProcessCheckerType.PING.getType()).isEqualTo("ping"); > - } > - > - @Test > - public void shouldBeTypeNative() { > - > assertThat(ProcessCheckerType.toEnum("native")).isEqualTo(ProcessCheckerType.NATIVE); > - > - assertThat(ProcessCheckerType.isValid("native")).isTrue(); > - > - assertThat(ProcessCheckerType.NATIVE.getType()).isEqualTo("native"); > - } > - > - @Test > - public void shouldBeTypeAll() { > - > assertThat(ProcessCheckerType.toEnum("all")).isEqualTo(ProcessCheckerType.ALL); > - > - assertThat(ProcessCheckerType.isValid("all")).isTrue(); > - > - assertThat(ProcessCheckerType.ALL.getType()).isEqualTo("all"); > - } > - > - @Test > - public void shouldCreateCheckerForCurrentProcess() { > - // Get current process PID using reflection to stay Java 8 compatible > - String currentPid = getCurrentPid(); > - if (currentPid == null) { > - // Skip test if we can't get PID > - return; > - } > - > - ProcessChecker checker = ProcessChecker.of(currentPid); > - > - assertThat(checker).isNotNull(); > - assertThat(checker.canUse()).isTrue(); > - assertThat(checker.isProcessAlive()).isTrue(); > - assertThat(checker.isStopped()).isFalse(); > - } > - > - @Test > - public void shouldSelectProcessHandleCheckerOnJava9Plus() { > - if (!ProcessChecker.isProcessHandleSupported()) { > - // Skip test if ProcessHandle is not available (Java 8) > - return; > - } > - > - String currentPid = getCurrentPid(); > - if (currentPid == null) { > - return; > - } > - > - ProcessChecker checker = ProcessChecker.of(currentPid); > - > assertThat(checker.getClass().getSimpleName()).isEqualTo("ProcessHandleChecker"); > - } > - > - @Test > - public void shouldStopChecker() { > - String currentPid = getCurrentPid(); > - if (currentPid == null) { > - return; > - } > - > - ProcessChecker checker = ProcessChecker.of(currentPid); > - > - assertThat(checker.canUse()).isTrue(); > - assertThat(checker.isStopped()).isFalse(); > - > - checker.stop(); > - > - assertThat(checker.isStopped()).isTrue(); > - assertThat(checker.canUse()).isFalse(); > - } > - > - @Test > - public void shouldDestroyActiveCommands() { > - String currentPid = getCurrentPid(); > - if (currentPid == null) { > - return; > - } > - > - ProcessChecker checker = ProcessChecker.of(currentPid); > - assertThat(checker.canUse()).isTrue(); > - > - checker.destroyActiveCommands(); > - > - assertThat(checker.isStopped()).isTrue(); > - assertThat(checker.canUse()).isFalse(); > - } > - > - @Test > - public void shouldHandleNonExistentProcess() { > - // Use an invalid PID that's unlikely to exist > - ProcessChecker checker = > ProcessChecker.of(Long.toString(Long.MAX_VALUE)); > - > - assertThat(checker).isNotNull(); > - > - assertThat(checker.canUse()).isTrue(); > - > - assertThat(checker.isProcessAlive()).isFalse(); > - } > - > - /** > - * Gets the current process PID in a way that works on both Java 8 and > Java 9+. > - */ > - private static String getCurrentPid() { > - // Try ProcessHandle (Java 9+) first via reflection > - try { > - Class<?> processHandleClass = > Class.forName("java.lang.ProcessHandle"); > - Object currentHandle = > processHandleClass.getMethod("current").invoke(null); > - Long pid = (Long) > processHandleClass.getMethod("pid").invoke(currentHandle); > - return String.valueOf(pid); > - } catch (Exception e) { > - // Fall back to ManagementFactory (works on Java 8) > - try { > - String name = > java.lang.management.ManagementFactory.getRuntimeMXBean() > - .getName(); > - // Format is "pid@hostname" > - int atIndex = name.indexOf('@'); > - if (atIndex > 0) { > - return name.substring(0, atIndex); > - } > - } catch (Exception ex) { > - // Ignore > - } > - } > - return null; > - } > -} > diff --git > a/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessHandleCheckerTest.java > > b/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessHandleCheckerTest.java > deleted file mode 100644 > index cc60e6122..000000000 > --- > a/surefire-booter/src/test/java/org/apache/maven/surefire/booter/ProcessHandleCheckerTest.java > +++ /dev/null > @@ -1,205 +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.maven.surefire.booter; > - > -import java.lang.management.ManagementFactory; > - > -import org.junit.Assume; > -import org.junit.Test; > - > -import static org.assertj.core.api.Assertions.assertThat; > -import static org.assertj.core.api.Assertions.assertThatThrownBy; > -import static org.junit.Assume.assumeTrue; > - > -/** > - * Tests for {@link ProcessHandleChecker}. > - * <p> > - * These tests use reflection-based PID detection to work on both Java 8 and > Java 9+. > - */ > -public class ProcessHandleCheckerTest { > - > - @Test > - public void shouldReportAvailableOnJava9Plus() { > - // This test runs on modern JVMs, so isAvailable() should return true > - // FIXME DisabledOnJre when we migrate to junit5 > - double v = > Double.parseDouble(System.getProperty("java.specification.version")); > - Assume.assumeTrue(v >= 9.0); > - assertThat(ProcessHandleChecker.isAvailable()).isTrue(); > - } > - > - @Test > - public void shouldDetectCurrentProcessAsAlive() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - assertThat(checker.canUse()).isTrue(); > - assertThat(checker.isProcessAlive()).isTrue(); > - assertThat(checker.isStopped()).isFalse(); > - } > - > - @Test > - public void shouldDetectNonExistentProcessAsNotUsable() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - // Use an invalid PID that's unlikely to exist > - ProcessHandleChecker checker = new ProcessHandleChecker("999999999"); > - > - assertThat(checker.canUse()).isTrue(); > - } > - > - @Test > - public void shouldStopChecker() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - assertThat(checker.canUse()).isTrue(); > - assertThat(checker.isStopped()).isFalse(); > - > - checker.stop(); > - > - assertThat(checker.isStopped()).isTrue(); > - assertThat(checker.canUse()).isFalse(); > - } > - > - @Test > - public void shouldDestroyActiveCommands() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - assertThat(checker.canUse()).isTrue(); > - > - checker.destroyActiveCommands(); > - > - assertThat(checker.isStopped()).isTrue(); > - assertThat(checker.canUse()).isFalse(); > - } > - > - @Test > - public void shouldReturnMeaningfulToString() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - String toString = checker.toString(); > - > - assertThat(toString) > - .contains("ProcessHandleChecker") > - .contains("pid=" + currentPid) > - .contains("stopped=false"); > - } > - > - @Test > - public void shouldReturnToStringWithStartInstantAfterCanUse() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - checker.canUse(); > - String toString = checker.toString(); > - > - > assertThat(toString).contains("ProcessHandleChecker").contains("hasHandle=true"); > - } > - > - @Test > - public void shouldCreateViaFactoryMethod() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessChecker checker = ProcessChecker.of(currentPid); > - > - assertThat(checker).isInstanceOf(ProcessHandleChecker.class); > - assertThat(checker.canUse()).isTrue(); > - assertThat(checker.isProcessAlive()).isTrue(); > - } > - > - @Test > - public void shouldReturnNullFromFactoryForNullPpid() { > - ProcessChecker checker = ProcessChecker.of(null); > - > - assertThat(checker).isNull(); > - } > - > - @Test > - public void shouldThrowOnInvalidPpidFormat() { > - assertThatThrownBy(() -> new > ProcessHandleChecker("not-a-number")).isInstanceOf(NumberFormatException.class); > - } > - > - @Test > - public void shouldReturnProcessInfoAfterCanUse() { > - assumeTrue("ProcessHandle not available", > ProcessHandleChecker.isAvailable()); > - > - String currentPid = getCurrentPid(); > - assumeTrue("Could not determine current PID", currentPid != null); > - > - ProcessHandleChecker checker = new ProcessHandleChecker(currentPid); > - > - // Now processInfo() should return valid info > - ProcessInfo processInfo = checker.processInfo(); > - assertThat(processInfo).isNotNull(); > - assertThat(processInfo.getPID()).isEqualTo(currentPid); > - assertThat(processInfo.getTime()).isGreaterThan(0L); > - } > - > - /** > - * Gets the current process PID using reflection (Java 8 compatible). > - * > - * @return the current process PID as a string, or null if it cannot be > determined > - */ > - private static String getCurrentPid() { > - // Try ProcessHandle.current().pid() via reflection (Java 9+) > - try { > - Class<?> processHandleClass = > Class.forName("java.lang.ProcessHandle"); > - Object currentHandle = > processHandleClass.getMethod("current").invoke(null); > - Long pid = (Long) > processHandleClass.getMethod("pid").invoke(currentHandle); > - return String.valueOf(pid); > - } catch (Exception e) { > - // Fall back to ManagementFactory (works on Java 8) > - try { > - String name = ManagementFactory.getRuntimeMXBean().getName(); > - int atIndex = name.indexOf('@'); > - if (atIndex > 0) { > - return name.substring(0, atIndex); > - } > - } catch (Exception ex) { > - // Ignore > - } > - } > - return null; > - } > -} >
--------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
