test: add test for plugins (#896)

* test: add test for plugins

* test: Adjust the time precision of test cases

hippo4j-core/src/main/java/cn/hippo4j/core/plugin/ExecuteAwarePlugin.java

@@ -32,6 +32,7 @@ public interface ExecuteAwarePlugin extends ThreadPoolPlugin {
      * @see ExtensibleThreadPoolExecutor#beforeExecute
      */
     default void beforeExecute(Thread thread, Runnable runnable) {
+        // do noting
     }
 
     /**

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/PluginRuntimeTest.java

@@ -0,0 +1,40 @@
+/*
+ * 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 cn.hippo4j.core.plugin;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * test for {@link PluginRuntime}
+ */
+public class PluginRuntimeTest {
+
+    @Test
+    public void test() {
+        PluginRuntime runtime = new PluginRuntime("test");
+        Assert.assertEquals("test", runtime.getPluginId());
+        Assert.assertTrue(runtime.getInfoList().isEmpty());
+
+        runtime.addInfo("item", "item");
+        PluginRuntime.Info info = runtime.getInfoList().get(0);
+        Assert.assertEquals("item", info.getName());
+        Assert.assertEquals("item", info.getValue());
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/ThreadPoolPluginTest.java

@@ -0,0 +1,92 @@
+/*
+ * 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 cn.hippo4j.core.plugin;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import lombok.Getter;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * test for default method of {@link ThreadPoolPlugin} and it's subclass
+ */
+public class ThreadPoolPluginTest {
+
+    @Test
+    public void testDefaultMethod() {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                1, 1, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+
+        executor.register(new TestTaskAwarePlugin());
+        executor.register(new TestExecuteAwarePlugin());
+        executor.register(new TestRejectedAwarePlugin());
+        executor.register(new TestShutdownAwarePlugin());
+
+        AtomicInteger count = new AtomicInteger(0);
+        executor.submit(() -> {
+            ThreadUtil.sleep(100L);
+            return count.incrementAndGet();
+        });
+        executor.submit(() -> {
+            ThreadUtil.sleep(100L);
+            count.incrementAndGet();
+        });
+        executor.submit(count::incrementAndGet, 2);
+
+        // waiting for shutdown
+        executor.shutdown();
+        while (!executor.isTerminated()) {
+        }
+
+        Assert.assertEquals(2, count.get());
+    }
+
+    @Getter
+    private final static class TestTaskAwarePlugin implements TaskAwarePlugin {
+
+        private final String id = this.getClass().getSimpleName();
+    }
+
+    @Getter
+    private final static class TestExecuteAwarePlugin implements ExecuteAwarePlugin {
+
+        private final String id = this.getClass().getSimpleName();
+    }
+
+    @Getter
+    private final static class TestRejectedAwarePlugin implements RejectedAwarePlugin {
+
+        private final String id = this.getClass().getSimpleName();
+    }
+
+    @Getter
+    private final static class TestShutdownAwarePlugin implements ShutdownAwarePlugin {
+
+        private final String id = this.getClass().getSimpleName();
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskDecoratorPluginTest.java

@@ -0,0 +1,103 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.PluginRuntime;
+import cn.hippo4j.core.plugin.ThreadPoolPlugin;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import org.junit.Assert;
+import org.junit.Test;
+import org.springframework.core.task.TaskDecorator;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * test for {@link TaskDecoratorPlugin}
+ */
+public class TaskDecoratorPluginTest {
+
+    private final AtomicInteger taskExecuteCount = new AtomicInteger(0);
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(TaskDecoratorPlugin.PLUGIN_NAME, new TaskDecoratorPlugin().getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        ThreadPoolPlugin plugin = new TaskDecoratorPlugin();
+        PluginRuntime runtime = new TaskDecoratorPlugin().getPluginRuntime();
+        Assert.assertNotNull(runtime);
+        Assert.assertEquals(plugin.getId(), runtime.getPluginId());
+    }
+
+    @Test
+    public void testAddDecorator() {
+        TaskDecoratorPlugin plugin = new TaskDecoratorPlugin();
+        plugin.addDecorator(runnable -> runnable);
+        plugin.addDecorator(runnable -> runnable);
+        Assert.assertEquals(2, plugin.getDecorators().size());
+    }
+
+    @Test
+    public void testRemoveDecorator() {
+        TaskDecoratorPlugin plugin = new TaskDecoratorPlugin();
+        TaskDecorator decorator = runnable -> runnable;
+        plugin.addDecorator(decorator);
+        plugin.removeDecorator(decorator);
+        Assert.assertTrue(plugin.getDecorators().isEmpty());
+    }
+
+    @Test
+    public void testClear() {
+        TaskDecoratorPlugin plugin = new TaskDecoratorPlugin();
+        TaskDecorator decorator = runnable -> runnable;
+        plugin.addDecorator(decorator);
+        plugin.addDecorator(decorator);
+        plugin.clearDecorators();
+        Assert.assertTrue(plugin.getDecorators().isEmpty());
+    }
+
+    @Test
+    public void testBeforeTaskExecute() {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                5, 5, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+        TaskDecoratorPlugin plugin = new TaskDecoratorPlugin();
+        plugin.addDecorator(runnable -> () -> {
+            taskExecuteCount.incrementAndGet();
+            runnable.run();
+        });
+        plugin.addDecorator(runnable -> () -> {
+            taskExecuteCount.incrementAndGet();
+            runnable.run();
+        });
+        executor.register(plugin);
+        executor.execute(() -> {
+        });
+        ThreadUtil.sleep(500L);
+        Assert.assertEquals(2, taskExecuteCount.get());
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectCountRecordPluginTest.java

@@ -0,0 +1,83 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * test for {@link TaskRejectCountRecordPlugin}
+ */
+public class TaskRejectCountRecordPluginTest {
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(TaskRejectCountRecordPlugin.PLUGIN_NAME, new TaskRejectCountRecordPlugin().getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        Assert.assertNotNull(new TaskRejectCountRecordPlugin().getPluginRuntime());
+    }
+
+    @Test
+    public void testGetRejectCountNum() {
+        TaskRejectCountRecordPlugin plugin = new TaskRejectCountRecordPlugin();
+        Assert.assertEquals((Long) 0L, plugin.getRejectCountNum());
+    }
+
+    @Test
+    public void testGetRejectCount() {
+        TaskRejectCountRecordPlugin plugin = new TaskRejectCountRecordPlugin();
+        Assert.assertEquals(0L, plugin.getRejectCount().get());
+    }
+
+    @Test
+    public void testSetRejectCount() {
+        TaskRejectCountRecordPlugin plugin = new TaskRejectCountRecordPlugin();
+        AtomicLong atomicLong = new AtomicLong(0);
+        plugin.setRejectCount(atomicLong);
+        Assert.assertSame(atomicLong, plugin.getRejectCount());
+    }
+
+    @Test
+    public void testBeforeRejectedExecution() {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                1, 1, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+
+        TaskRejectCountRecordPlugin plugin = new TaskRejectCountRecordPlugin();
+        executor.register(plugin);
+        executor.submit(() -> ThreadUtil.sleep(500L));
+        executor.submit(() -> ThreadUtil.sleep(500L));
+        executor.submit(() -> ThreadUtil.sleep(500L));
+
+        ThreadUtil.sleep(500L);
+        Assert.assertEquals((Long) 1L, plugin.getRejectCountNum());
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectNotifyAlarmPluginTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import lombok.RequiredArgsConstructor;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * test for {@link TaskRejectNotifyAlarmPlugin}
+ */
+public class TaskRejectNotifyAlarmPluginTest {
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(TaskRejectNotifyAlarmPlugin.PLUGIN_NAME, new TaskRejectNotifyAlarmPlugin().getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        Assert.assertNotNull(new TaskRejectNotifyAlarmPlugin().getPluginRuntime());
+    }
+
+    @Test
+    public void testBeforeRejectedExecution() {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                1, 1, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+
+        AtomicInteger rejectCount = new AtomicInteger(0);
+        executor.register(new TestPlugin(rejectCount, executor));
+        executor.submit(() -> ThreadUtil.sleep(200L));
+        executor.submit(() -> ThreadUtil.sleep(200L));
+        executor.submit(() -> ThreadUtil.sleep(200L));
+
+        // waiting for shutdown
+        executor.shutdown();
+        while (!executor.isTerminated()) {
+        }
+        Assert.assertEquals(1, rejectCount.get());
+    }
+
+    @RequiredArgsConstructor
+    private static class TestPlugin extends TaskRejectNotifyAlarmPlugin {
+
+        private final AtomicInteger count;
+        private final ThreadPoolExecutor targetExecutor;
+
+        /**
+         * Callback before task is rejected.
+         *
+         * @param runnable task
+         * @param executor executor
+         */
+        @Override
+        public void beforeRejectedExecution(Runnable runnable, ThreadPoolExecutor executor) {
+            count.incrementAndGet();
+            Assert.assertEquals(targetExecutor, executor);
+            super.beforeRejectedExecution(runnable, executor);
+        }
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeRecordPluginTest.java

@@ -0,0 +1,68 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * test for {@link TaskTimeRecordPlugin}
+ */
+public class TaskTimeRecordPluginTest {
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(TaskTimeRecordPlugin.PLUGIN_NAME, new TaskTimeRecordPlugin().getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        Assert.assertNotNull(new TaskTimeRecordPlugin().getPluginRuntime());
+    }
+
+    @Test
+    public void testSummarize() {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                3, 3, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+
+        TaskTimeRecordPlugin plugin = new TaskTimeRecordPlugin();
+        executor.register(plugin);
+        executor.submit(() -> ThreadUtil.sleep(1000L));
+        executor.submit(() -> ThreadUtil.sleep(3000L));
+        executor.submit(() -> ThreadUtil.sleep(2000L));
+
+        // waiting for shutdown
+        executor.shutdown();
+        while (!executor.isTerminated()) {
+        }
+        TaskTimeRecordPlugin.Summary summary = plugin.summarize();
+        Assert.assertEquals(1, summary.getMinTaskTimeMillis() / 1000L);
+        Assert.assertEquals(3, summary.getMaxTaskTimeMillis() / 1000L);
+        Assert.assertEquals(2, summary.getAvgTaskTimeMillis() / 1000L);
+        Assert.assertEquals(6, summary.getTotalTaskTimeMillis() / 1000L);
+    }
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeoutNotifyAlarmPluginTest.java

@@ -0,0 +1,86 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * test for {@link TaskTimeoutNotifyAlarmPlugin}
+ */
+public class TaskTimeoutNotifyAlarmPluginTest {
+
+    private final ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+            "test", new DefaultThreadPoolPluginManager(),
+            5, 5, 1000L, TimeUnit.MILLISECONDS,
+            new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.AbortPolicy());
+
+    private final TaskTimeoutNotifyAlarmPlugin plugin = new TaskTimeoutNotifyAlarmPlugin(
+            executor.getThreadPoolId(), 100L, executor);
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(TaskTimeoutNotifyAlarmPlugin.PLUGIN_NAME, plugin.getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        Assert.assertNotNull(plugin.getPluginRuntime());
+    }
+
+    @Test
+    public void testGetExecuteTimeOut() {
+        Assert.assertEquals(100L, plugin.getExecuteTimeOut().longValue());
+    }
+
+    @Test
+    public void testSetExecuteTimeOut() {
+        plugin.setExecuteTimeOut(200L);
+        Assert.assertEquals(200L, plugin.getExecuteTimeOut().longValue());
+    }
+
+    @Test
+    public void testProcessTaskTime() {
+        executor.register(plugin);
+
+        AtomicInteger count = new AtomicInteger(0);
+        executor.submit(() -> {
+            count.incrementAndGet();
+            ThreadUtil.sleep(100L);
+        });
+        executor.submit(() -> {
+            count.incrementAndGet();
+            ThreadUtil.sleep(300L);
+        });
+
+        // waiting for shutdown
+        executor.shutdown();
+        while (!executor.isTerminated()) {
+        }
+        Assert.assertEquals(2, count.get());
+    }
+
+}

hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/ThreadPoolExecutorShutdownPluginTest.java

@@ -0,0 +1,91 @@
+/*
+ * 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 cn.hippo4j.core.plugin.impl;
+
+import cn.hippo4j.common.toolkit.ThreadUtil;
+import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
+import cn.hippo4j.core.plugin.ThreadPoolPlugin;
+import cn.hippo4j.core.plugin.manager.DefaultThreadPoolPluginManager;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * test for {@link ThreadPoolExecutorShutdownPlugin}
+ */
+public class ThreadPoolExecutorShutdownPluginTest {
+
+    @Test
+    public void testGetId() {
+        Assert.assertEquals(ThreadPoolExecutorShutdownPlugin.PLUGIN_NAME, new ThreadPoolExecutorShutdownPlugin(1000L).getId());
+    }
+
+    @Test
+    public void testGetRuntime() {
+        Assert.assertNotNull(new ThreadPoolExecutorShutdownPlugin(1000L).getPluginRuntime());
+    }
+
+    @Test
+    public void testGetAwaitTerminationMillis() {
+        ThreadPoolExecutorShutdownPlugin plugin = new ThreadPoolExecutorShutdownPlugin(1000L);
+        Assert.assertEquals(1000L, plugin.getAwaitTerminationMillis());
+    }
+
+    @Test
+    public void testSetAwaitTerminationMillis() {
+        ThreadPoolExecutorShutdownPlugin plugin = new ThreadPoolExecutorShutdownPlugin(1000L);
+        plugin.setAwaitTerminationMillis(5000L);
+        Assert.assertEquals(5000L, plugin.getAwaitTerminationMillis());
+    }
+
+    public ExtensibleThreadPoolExecutor getExecutor(ThreadPoolPlugin plugin) {
+        ExtensibleThreadPoolExecutor executor = new ExtensibleThreadPoolExecutor(
+                "test", new DefaultThreadPoolPluginManager(),
+                2, 2, 1000L, TimeUnit.MILLISECONDS,
+                new ArrayBlockingQueue<>(1), Thread::new, new ThreadPoolExecutor.DiscardPolicy());
+        executor.register(plugin);
+        return executor;
+    }
+
+    private static Callable<Integer> getCallable(AtomicInteger completedCount) {
+        return () -> {
+            ThreadUtil.sleep(1000L);
+            return completedCount.incrementAndGet();
+        };
+    }
+
+    @Test
+    public void testShutdown() {
+        ExtensibleThreadPoolExecutor executor = getExecutor(
+                new ThreadPoolExecutorShutdownPlugin(2000L));
+
+        AtomicInteger completedCount = new AtomicInteger(0);
+        executor.submit(getCallable(completedCount));
+        executor.submit(getCallable(completedCount));
+        executor.submit(getCallable(completedCount));
+
+        executor.shutdownNow();
+        Assert.assertEquals(2, completedCount.get());
+    }
+
+}