如何在测试断言前等待方法及其内部线程执行完成？

针对你不想修改原有代码但要替换Thread.sleep()的需求，这里提供几种可行的测试方案：

方案1：反射获取内部ExecutorService并等待终止 #

利用反射拿到ManagerClass里的单线程执行器，调用shutdown()和awaitTermination()等待异步任务完成：

managerClass.methodIWantToTest(/* params */);

// 反射获取私有executor字段
Field executorField = ManagerClass.class.getDeclaredField("executor");
executorField.setAccessible(true);
ExecutorService executor = (ExecutorService) executorField.get(managerClass);

// 关闭执行器并等待任务完成（最多5秒超时）
executor.shutdown();
boolean isTerminated = executor.awaitTermination(5, TimeUnit.SECONDS);
assertTrue("异步任务未在超时时间内执行完成", isTerminated);

// 执行断言
List<Things> list = managerClass.getListOfThings(); 
assertEquals(1, list.size()); 
// 更多断言

注意：该方案依赖类内部的字段名executor，如果后续代码修改了这个字段名，测试会失败。

方案2：用CountDownLatch结合PowerMock拦截任务执行 #

如果允许引入PowerMock测试框架，可以拦截执行器的execute()方法，在任务完成时触发计数信号：

@RunWith(PowerMockRunner.class)
@PrepareForTest(ManagerClass.class)
public class ManagerClassTest {

    @Test
    public void testMethodIWantToTest() throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        ManagerClass managerClass = new ManagerClass();

        // 反射获取原执行器
        Field executorField = ManagerClass.class.getDeclaredField("executor");
        executorField.setAccessible(true);
        ExecutorService originalExecutor = (ExecutorService) executorField.get(managerClass);

        // 创建代理执行器，包装任务并在完成后触发latch
        ExecutorService proxyExecutor = mock(ExecutorService.class);
        doAnswer(invocation -> {
            Runnable task = invocation.getArgument(0);
            originalExecutor.execute(() -> {
                try {
                    task.run();
                } finally {
                    latch.countDown();
                }
            });
            return null;
        }).when(proxyExecutor).execute(any(Runnable.class));

        // 替换原执行器
        executorField.set(managerClass, proxyExecutor);

        // 调用目标方法
        managerClass.methodIWantToTest(/* params */);

        // 等待任务完成（最多5秒）
        assertTrue("任务超时未完成", latch.await(5, TimeUnit.SECONDS));

        // 执行断言
        List<Things> list = managerClass.getListOfThings(); 
        assertEquals(1, list.size()); 
        // 更多断言
    }
}

优势：不直接依赖任务内部逻辑，仅通过执行器拦截实现等待，灵活性更高。

方案3：轮询等待断言条件满足 #

如果不想用反射或额外框架，可以循环检查断言的目标条件，直到满足或超时：

managerClass.methodIWantToTest(/* params */);

long timeoutMillis = 5000;
long start = System.currentTimeMillis();
List<Things> targetList = null;

while (System.currentTimeMillis() - start < timeoutMillis) {
    targetList = managerClass.getListOfThings();
    if (targetList != null && targetList.size() == 1) {
        break;
    }
    Thread.sleep(100); // 短间隔休眠，降低CPU占用
}

// 执行断言
assertNotNull("目标列表未初始化", targetList);
assertEquals(1, targetList.size());
// 更多断言

特点：无额外依赖，不侵入原有代码，但需要确保断言条件可以被外部检查。

内容的提问来源于stack exchange，提问作者Tyrannogyna