[LANG-1817] UncheckedFutureImpl clears thread interrupt status when

wrapping InterruptedException.

Partial application of patch #1590.

Author: garydgregory

src/changes/changes.xml

@@ -114,6 +114,7 @@ The <action> type attribute can be add,update,fix,remove.
     <action                   type="fix" dev="ggregory" due-to="Ivan Ponomarev, Gary Gregory">Fix StringIndexOutOfBoundsException message in StrBuilder.append(char[], int, int).</action>
     <action issue="LANG-1818" type="fix" dev="ggregory" due-to="Ivan Ponomarev, Gary Gregory">Fix ClassUtils.getShortClassName(Class) to correctly handle $ in valid class names #1591.</action>
     <action                   type="fix" dev="ggregory" due-to="Ivan Ponomarev, Gary Gregory">ThreadUtils.sleepQuietly(Duration) now restores the current thread's interrupt flag when catching InterruptedException.</action>
+    <action issue="LANG-1817" type="fix" dev="ggregory" due-to="Ivan Ponomarev, Gary Gregory">UncheckedFutureImpl clears thread interrupt status when wrapping InterruptedException #1590.</action>
     <!-- ADD -->
     <action                   type="add" dev="ggregory" due-to="Gary Gregory">Add JavaVersion.JAVA_27.</action>
     <action                   type="add" dev="ggregory" due-to="Gary Gregory">Add SystemUtils.IS_JAVA_27.</action>

src/main/java/org/apache/commons/lang3/concurrent/UncheckedFutureImpl.java

@@ -42,6 +42,7 @@ public V get() {
         try {
             return super.get();
         } catch (final InterruptedException e) {
+            Thread.currentThread().interrupt();
             throw new UncheckedInterruptedException(e);
         } catch (final ExecutionException e) {
             throw new UncheckedExecutionException(e);
@@ -53,6 +54,7 @@ public V get(final long timeout, final TimeUnit unit) {
         try {
             return super.get(timeout, unit);
         } catch (final InterruptedException e) {
+            Thread.currentThread().interrupt();
             throw new UncheckedInterruptedException(e);
         } catch (final ExecutionException e) {
             throw new UncheckedExecutionException(e);

src/test/java/org/apache/commons/lang3/concurrent/UncheckedFutureTest.java

@@ -18,14 +18,20 @@
 package org.apache.commons.lang3.concurrent;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.AbstractLangTest;
@@ -121,4 +127,62 @@ void testOnFuture() {
         assertEquals("Z", UncheckedFuture.on(new TestFuture<>("Z")).get());
     }
 
+
+    @Test
+    void interruptFlagIsPreservedOnGet() throws Exception {
+        assertInterruptPreserved(UncheckedFuture::get);
+    }
+
+    @Test
+    void interruptFlagIsPreservedOnGetWithTimeout() throws Exception {
+        assertInterruptPreserved(uf -> uf.get(1, TimeUnit.DAYS));
+    }
+
+    private static void assertInterruptPreserved(Consumer<UncheckedFuture<Integer>> call) throws Exception {
+        final CountDownLatch enteredGet = new CountDownLatch(1);
+        final Future<Integer> blockingFuture = new AbstractFutureProxy<Integer>(ConcurrentUtils.constantFuture(42)) {
+            private final CountDownLatch neverRelease = new CountDownLatch(1);
+
+            @Override
+            public Integer get() throws InterruptedException {
+                enteredGet.countDown();
+                neverRelease.await();
+                throw new AssertionError("We should not get here");
+            }
+
+            @Override
+            public Integer get(long timeout, TimeUnit unit) throws InterruptedException {
+                enteredGet.countDown();
+                neverRelease.await();
+                throw new AssertionError("We should not get here");
+            }
+
+            @Override
+            public boolean isDone() {
+                return false;
+            }
+
+        };
+        final UncheckedFuture<Integer> uf = UncheckedFuture.on(blockingFuture);
+        final AtomicReference<Throwable> thrown = new AtomicReference<>();
+        final AtomicBoolean interruptObserved = new AtomicBoolean(false);
+        final Thread worker = new Thread(() -> {
+            try {
+                call.accept(uf);
+                thrown.set(new AssertionError("We should not get here"));
+            } catch (Throwable e) {
+                interruptObserved.set(Thread.currentThread().isInterrupted());
+                thrown.set(e);
+            }
+        }, "unchecked-future-test-worker");
+        worker.start();
+        assertTrue(enteredGet.await(2, TimeUnit.SECONDS), "Worker did not enter Future.get() in time");
+        worker.interrupt();
+        worker.join();
+        final Throwable t = thrown.get();
+        assertInstanceOf(UncheckedInterruptedException.class, t, "Unexpected exception: " + t);
+        assertInstanceOf(InterruptedException.class, t.getCause(), "Cause should be InterruptedException");
+        assertTrue(interruptObserved.get(), "Interrupt flag was not restored by the wrapper");
+    }
+
 }