andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove use of PlatformDependent.throwsException in SingleThreadEventExecutor (#10827)

Browse Source 
Motivation:
We should avoid lying with throws declarations whenever possible.

Modification:
Changed the code to instead directly throw Error, which seems to have been the intent.
Also, while we're here, convert its associated test to JUnit 5 and clean it up a bit.

Result:
Cleaner code.
This commit is contained in:
Chris Vest 2020-11-26 11:37:47 +01:00 committed by GitHub
parent 2dae6665f4
commit db4f85a479
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 84 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
common/src/main/java/io/netty/util/concurrent/SingleThreadEventExecutor.java
View File

@ -831,9 +831,9 @@ public class SingleThreadEventExecutor extends AbstractScheduledEventExecutor im
STATE_UPDATER.set(this, ST_TERMINATED);
terminationFuture.tryFailure(cause);
if (!(cause instanceof Exception)) {
// Also rethrow as it may be an OOME for example
PlatformDependent.throwException(cause);
if (cause instanceof Error) {
// Rethrow errors so they can't be ignored.
throw cause;
}
return true;
}

125
common/src/test/java/io/netty/util/concurrent/SingleThreadEventExecutorTest.java
View File

@ -15,9 +15,7 @@
*/
package io.netty.util.concurrent;
import org.hamcrest.CoreMatchers;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.Queue;
@ -34,11 +32,16 @@ import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*;
import static java.time.Duration.ofSeconds;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class SingleThreadEventExecutorTest {
public static final Runnable DUMMY_TASK = () -> {
};
@Test
public void testWrappedExecutorIsShutdown() {
@ -59,25 +62,14 @@ public class SingleThreadEventExecutorTest {
executorService.shutdownNow();
executeShouldFail(executor);
executeShouldFail(executor);
try {
executor.shutdownGracefully().syncUninterruptibly();
Assert.fail();
} catch (CompletionException expected) {
// expected
Assert.assertThat(expected.getCause(), CoreMatchers.instanceOf(RejectedExecutionException.class));
}
Assert.assertTrue(executor.isShutdown());
var exception = assertThrows(
CompletionException.class, () -> executor.shutdownGracefully().syncUninterruptibly());
assertThat(exception).hasCauseInstanceOf(RejectedExecutionException.class);
assertTrue(executor.isShutdown());
}
private static void executeShouldFail(Executor executor) {
try {
executor.execute(() -> {
// Noop.
});
Assert.fail();
} catch (RejectedExecutionException expected) {
// expected
}
assertThrows(RejectedExecutionException.class, () -> executor.execute(DUMMY_TASK));
}
@Test
@ -98,49 +90,45 @@ public class SingleThreadEventExecutorTest {
ThreadProperties threadProperties = executor.threadProperties();
Thread thread = threadRef.get();
Assert.assertEquals(thread.getId(), threadProperties.id());
Assert.assertEquals(thread.getName(), threadProperties.name());
Assert.assertEquals(thread.getPriority(), threadProperties.priority());
Assert.assertEquals(thread.isAlive(), threadProperties.isAlive());
Assert.assertEquals(thread.isDaemon(), threadProperties.isDaemon());
Assert.assertTrue(threadProperties.stackTrace().length > 0);
assertEquals(thread.getId(), threadProperties.id());
assertEquals(thread.getName(), threadProperties.name());
assertEquals(thread.getPriority(), threadProperties.priority());
assertEquals(thread.isAlive(), threadProperties.isAlive());
assertEquals(thread.isDaemon(), threadProperties.isDaemon());
assertTrue(threadProperties.stackTrace().length > 0);
executor.shutdownGracefully();
}
@Test(expected = RejectedExecutionException.class, timeout = 3000)
@Test
public void testInvokeAnyInEventLoop() throws Throwable {
try {
testInvokeInEventLoop(true, false);
} catch (CompletionException e) {
throw e.getCause();
}
assertTimeoutPreemptively(ofSeconds(3), () -> {
var exception = assertThrows(CompletionException.class, () -> testInvokeInEventLoop(true, false));
assertThat(exception).hasCauseInstanceOf(RejectedExecutionException.class);
});
}
@Test(expected = RejectedExecutionException.class, timeout = 3000)
@Test
public void testInvokeAnyInEventLoopWithTimeout() throws Throwable {
try {
testInvokeInEventLoop(true, true);
} catch (CompletionException e) {
throw e.getCause();
}
assertTimeoutPreemptively(ofSeconds(3), () -> {
var exception = assertThrows(CompletionException.class, () -> testInvokeInEventLoop(true, true));
assertThat(exception).hasCauseInstanceOf(RejectedExecutionException.class);
});
}
@Test(expected = RejectedExecutionException.class, timeout = 3000)
@Test
public void testInvokeAllInEventLoop() throws Throwable {
try {
testInvokeInEventLoop(false, false);
} catch (CompletionException e) {
throw e.getCause();
}
assertTimeoutPreemptively(ofSeconds(3), () -> {
var exception = assertThrows(CompletionException.class, () -> testInvokeInEventLoop(false, false));
assertThat(exception).hasCauseInstanceOf(RejectedExecutionException.class);
});
}
@Test(expected = RejectedExecutionException.class, timeout = 3000)
@Test
public void testInvokeAllInEventLoopWithTimeout() throws Throwable {
try {
testInvokeInEventLoop(false, true);
} catch (CompletionException e) {
throw e.getCause();
}
assertTimeoutPreemptively(ofSeconds(3), () -> {
var exception = assertThrows(CompletionException.class, () -> testInvokeInEventLoop(false, true));
assertThat(exception).hasCauseInstanceOf(RejectedExecutionException.class);
});
}
private static void testInvokeInEventLoop(final boolean any, final boolean timeout) {
@ -198,9 +186,6 @@ public class SingleThreadEventExecutorTest {
}
};
final Runnable dummyTask = () -> {
};
final LinkedBlockingQueue<Future<?>> submittedTasks = new LinkedBlockingQueue<Future<?>>();
final AtomicInteger attempts = new AtomicInteger();
final AtomicInteger rejects = new AtomicInteger();
@ -231,7 +216,7 @@ public class SingleThreadEventExecutorTest {
if (result) {
attempts.incrementAndGet();
try {
submittedTasks.add(submit(dummyTask));
submittedTasks.add(submit(DUMMY_TASK));
} catch (RejectedExecutionException e) {
// ignore, tasks are either accepted or rejected
rejects.incrementAndGet();
@ -242,24 +227,24 @@ public class SingleThreadEventExecutorTest {
};
// Start the loop
executor.submit(dummyTask).sync();
executor.submit(DUMMY_TASK).sync();
// Shutdown without any quiet period
executor.shutdownGracefully(0, 100, TimeUnit.MILLISECONDS).sync();
// Ensure there are no user-tasks left.
Assert.assertEquals(0, executor.drainTasks());
assertEquals(0, executor.drainTasks());
// Verify that queue is empty and all attempts either succeeded or were rejected
Assert.assertTrue(taskQueue.isEmpty());
Assert.assertTrue(attempts.get() > 0);
Assert.assertEquals(attempts.get(), submittedTasks.size() + rejects.get());
assertTrue(taskQueue.isEmpty());
assertTrue(attempts.get() > 0);
assertEquals(attempts.get(), submittedTasks.size() + rejects.get());
for (Future<?> f : submittedTasks) {
Assert.assertTrue(f.isSuccess());
assertTrue(f.isSuccess());
}
}
@Test(timeout = 5000)
@Test
public void testTakeTask() throws Exception {
final SingleThreadEventExecutor executor =
new SingleThreadEventExecutor(Executors.defaultThreadFactory()) {
@ -274,6 +259,7 @@ public class SingleThreadEventExecutorTest {
}
};
assertTimeoutPreemptively(ofSeconds(5), () -> {
//add task
TestRunnable beforeTask = new TestRunnable();
executor.execute(beforeTask);
@ -288,12 +274,13 @@ public class SingleThreadEventExecutorTest {
f.sync();
assertThat(beforeTask.ran.get(), is(true));
assertThat(scheduledTask.ran.get(), is(true));
assertThat(afterTask.ran.get(), is(true));
assertThat(beforeTask.ran.get()).isTrue();
assertThat(scheduledTask.ran.get()).isTrue();
assertThat(afterTask.ran.get()).isTrue();
});
}
@Test(timeout = 5000)
@Test
public void testTakeTaskAlwaysHasTask() throws Exception {
//for https://github.com/netty/netty/issues/1614
@ -310,6 +297,7 @@ public class SingleThreadEventExecutorTest {
}
};
assertTimeoutPreemptively(ofSeconds(5), () -> {
//add scheduled task
TestRunnable t = new TestRunnable();
final ScheduledFuture<?> f = executor.schedule(t, 1500, TimeUnit.MILLISECONDS);
@ -327,7 +315,8 @@ public class SingleThreadEventExecutorTest {
f.sync();
assertThat(t.ran.get(), is(true));
assertThat(t.ran.get()).isTrue();
});
}
private static final class TestRunnable implements Runnable {