diff --git a/hippo4j-core/src/main/java/cn/hippo4j/core/plugin/ExecuteAwarePlugin.java b/hippo4j-core/src/main/java/cn/hippo4j/core/plugin/ExecuteAwarePlugin.java index d6c8638a..19148432 100644 --- a/hippo4j-core/src/main/java/cn/hippo4j/core/plugin/ExecuteAwarePlugin.java +++ b/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 } /** diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/PluginRuntimeTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/PluginRuntimeTest.java new file mode 100644 index 00000000..80281460 --- /dev/null +++ b/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()); + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/ThreadPoolPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/ThreadPoolPluginTest.java new file mode 100644 index 00000000..423400bf --- /dev/null +++ b/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(); + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskDecoratorPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskDecoratorPluginTest.java new file mode 100644 index 00000000..09f84f8f --- /dev/null +++ b/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()); + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectCountRecordPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectCountRecordPluginTest.java new file mode 100644 index 00000000..a4ae9125 --- /dev/null +++ b/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()); + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectNotifyAlarmPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskRejectNotifyAlarmPluginTest.java new file mode 100644 index 00000000..1842f3ef --- /dev/null +++ b/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); + } + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeRecordPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeRecordPluginTest.java new file mode 100644 index 00000000..d7866a28 --- /dev/null +++ b/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); + } +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeoutNotifyAlarmPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/TaskTimeoutNotifyAlarmPluginTest.java new file mode 100644 index 00000000..732d4915 --- /dev/null +++ b/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()); + } + +} diff --git a/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/ThreadPoolExecutorShutdownPluginTest.java b/hippo4j-core/src/test/java/cn/hippo4j/core/plugin/impl/ThreadPoolExecutorShutdownPluginTest.java new file mode 100644 index 00000000..056dc1bd --- /dev/null +++ b/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 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()); + } + +} \ No newline at end of file