1. 手动合并存在重复被合并的文件，并统一包名

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateDeptLeaderMultiStrategyTest.java

@@ -0,0 +1,45 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import com.zt.plat.framework.common.pojo.CommonResult;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.system.api.dept.DeptApi;
+import com.zt.plat.module.system.api.dept.dto.DeptRespDTO;
+import org.assertj.core.util.Sets;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.stubbing.Answer;
+
+import java.util.Set;
+
+import static com.zt.plat.framework.common.pojo.CommonResult.success;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateDeptLeaderMultiStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateDeptLeaderMultiStrategy strategy;
+
+    @Mock
+    private DeptApi deptApi;
+
+    @Test
+    public void testCalculateUsers() {
+        // 准备参数
+        String param = "10,20|2";
+        // mock 方法
+        when(deptApi.getDept(any())).thenAnswer((Answer< CommonResult<DeptRespDTO>>) invocationOnMock -> {
+            Long deptId = invocationOnMock.getArgument(0);
+            return success(randomPojo(DeptRespDTO.class, o -> o.setId(deptId).setParentId(deptId * 100).setLeaderUserId(deptId + 1)));
+        });
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsers(param);
+        // 断言结果
+        assertEquals(Sets.newLinkedHashSet(11L, 1001L, 21L, 2001L), userIds);
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateDeptLeaderStrategyTest.java

@@ -0,0 +1,44 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import com.zt.plat.framework.common.util.collection.SetUtils;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.system.api.dept.DeptApi;
+import com.zt.plat.module.system.api.dept.dto.DeptRespDTO;
+import org.assertj.core.util.Sets;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.Set;
+
+import static com.zt.plat.framework.common.pojo.CommonResult.success;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static java.util.Arrays.asList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateDeptLeaderStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateDeptLeaderStrategy strategy;
+
+    @Mock
+    private DeptApi deptApi;
+
+    @Test
+    public void testCalculateUsers() {
+        // 准备参数
+        String param = "10,20";
+        // mock 方法
+        when(deptApi.getDeptList(eq(SetUtils.asSet(10L, 20L)))).thenReturn(success(asList(
+                randomPojo(DeptRespDTO.class, o -> o.setId(10L).setParentId(10L).setLeaderUserId(11L)),
+                randomPojo(DeptRespDTO.class, o -> o.setId(20L).setParentId(20L).setLeaderUserId(21L)))));
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsers(param);
+        // 断言结果
+        assertEquals(Sets.newLinkedHashSet(11L, 21L), userIds);
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateDeptMemberStrategyTest.java

@@ -0,0 +1,47 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import com.zt.plat.framework.common.util.collection.SetUtils;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.system.api.dept.DeptApi;
+import com.zt.plat.module.system.api.user.AdminUserApi;
+import com.zt.plat.module.system.api.user.dto.AdminUserRespDTO;
+import org.assertj.core.util.Sets;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.Set;
+
+import static com.zt.plat.framework.common.pojo.CommonResult.success;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static java.util.Arrays.asList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateDeptMemberStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateDeptMemberStrategy strategy;
+
+    @Mock
+    private DeptApi deptApi;
+    @Mock
+    private AdminUserApi adminUserApi;
+
+    @Test
+    public void testCalculateUsers() {
+        // 准备参数
+        String param = "10,20";
+        // mock 方法
+        when(adminUserApi.getUserListByDeptIds(eq(SetUtils.asSet(10L, 20L)))).thenReturn(success(asList(
+                randomPojo(AdminUserRespDTO.class, o -> o.setId(11L)),
+                randomPojo(AdminUserRespDTO.class, o -> o.setId(21L)))));
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsers(param);
+        // 断言结果
+        assertEquals(Sets.newLinkedHashSet(11L, 21L), userIds);
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateStartUserDeptLeaderMultiStrategyTest.java

@@ -0,0 +1,85 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import com.zt.plat.framework.common.pojo.CommonResult;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.bpm.service.task.BpmProcessInstanceService;
+import com.zt.plat.module.system.api.dept.DeptApi;
+import com.zt.plat.module.system.api.dept.dto.DeptRespDTO;
+import com.zt.plat.module.system.api.user.AdminUserApi;
+import com.zt.plat.module.system.api.user.dto.AdminUserRespDTO;
+import org.assertj.core.util.Sets;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.stubbing.Answer;
+
+import java.util.Collections;
+import java.util.Set;
+
+import static com.zt.plat.framework.common.pojo.CommonResult.success;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateStartUserDeptLeaderMultiStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateStartUserDeptLeaderMultiStrategy strategy;
+
+    @Mock
+    private BpmProcessInstanceService processInstanceService;
+
+    @Mock
+    private AdminUserApi adminUserApi;
+    @Mock
+    private DeptApi deptApi;
+
+    @Test
+    public void testCalculateUsersByTask() {
+        // 准备参数
+        String param = "2";
+        // mock 方法（获得流程发起人）
+        Long startUserId = 1L;
+        ProcessInstance processInstance = mock(ProcessInstance.class);
+        DelegateExecution execution = mock(DelegateExecution.class);
+        when(processInstanceService.getProcessInstance(eq(execution.getProcessInstanceId()))).thenReturn(processInstance);
+        when(processInstance.getStartUserId()).thenReturn(startUserId.toString());
+        // mock 方法（获取发起人的 multi 部门负责人）
+        mockGetStartUserDept(startUserId);
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByTask(execution, param);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(11L, 1001L), userIds);
+    }
+
+    @Test
+    public void testCalculateUsersByActivity() {
+        // 准备参数
+        String param = "2";
+        // mock 方法
+        Long startUserId = 1L;
+        mockGetStartUserDept(startUserId);
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByActivity(null, null, param,
+                startUserId, null, null);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(11L, 1001L), userIds);
+    }
+
+    private void mockGetStartUserDept(Long startUserId) {
+        when(adminUserApi.getUser(eq(startUserId))).thenReturn(
+                success(randomPojo(AdminUserRespDTO.class, o -> o.setId(startUserId).setDeptIds(Collections.singletonList(10L)))));
+        when(deptApi.getDept(any())).thenAnswer((Answer< CommonResult<DeptRespDTO>>) invocationOnMock -> {
+            Long deptId = invocationOnMock.getArgument(0);
+            return success(randomPojo(DeptRespDTO.class, o -> o.setId(deptId).setParentId(deptId * 100).setLeaderUserId(deptId + 1)));
+        });
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateStartUserDeptLeaderStrategyTest.java

@@ -0,0 +1,85 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import com.zt.plat.framework.common.pojo.CommonResult;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.bpm.service.task.BpmProcessInstanceService;
+import com.zt.plat.module.system.api.dept.DeptApi;
+import com.zt.plat.module.system.api.dept.dto.DeptRespDTO;
+import com.zt.plat.module.system.api.user.AdminUserApi;
+import com.zt.plat.module.system.api.user.dto.AdminUserRespDTO;
+import org.assertj.core.util.Sets;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.stubbing.Answer;
+
+import java.util.Collections;
+import java.util.Set;
+
+import static com.zt.plat.framework.common.pojo.CommonResult.success;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateStartUserDeptLeaderStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateStartUserDeptLeaderStrategy strategy;
+
+    @Mock
+    private BpmProcessInstanceService processInstanceService;
+
+    @Mock
+    private AdminUserApi adminUserApi;
+    @Mock
+    private DeptApi deptApi;
+
+    @Test
+    public void testCalculateUsersByTask() {
+        // 准备参数
+        String param = "2";
+        // mock 方法（获得流程发起人）
+        Long startUserId = 1L;
+        ProcessInstance processInstance = mock(ProcessInstance.class);
+        DelegateExecution execution = mock(DelegateExecution.class);
+        when(processInstanceService.getProcessInstance(eq(execution.getProcessInstanceId()))).thenReturn(processInstance);
+        when(processInstance.getStartUserId()).thenReturn(startUserId.toString());
+        // mock 方法（获取发起人的部门负责人）
+        mockGetStartUserDeptLeader(startUserId);
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByTask(execution, param);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(1001L), userIds);
+    }
+
+    @Test
+    public void testGetStartUserDeptLeader() {
+        // 准备参数
+        String param = "2";
+        // mock 方法
+        Long startUserId = 1L;
+        mockGetStartUserDeptLeader(startUserId);
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByActivity(null, null, param,
+                startUserId, null, null);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(1001L), userIds);
+    }
+
+    private void mockGetStartUserDeptLeader(Long startUserId) {
+        when(adminUserApi.getUser(eq(startUserId))).thenReturn(
+                success(randomPojo(AdminUserRespDTO.class, o -> o.setId(startUserId).setDeptIds(Collections.singletonList(10L)))));
+        when(deptApi.getDept(any())).thenAnswer((Answer< CommonResult<DeptRespDTO>>) invocationOnMock -> {
+            Long deptId = invocationOnMock.getArgument(0);
+            return success(randomPojo(DeptRespDTO.class, o -> o.setId(deptId).setParentId(deptId * 100).setLeaderUserId(deptId + 1)));
+        });
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/dept/BpmTaskCandidateStartUserSelectStrategyTest.java

@@ -0,0 +1,68 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.dept;
+
+import cn.hutool.core.map.MapUtil;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.bpm.framework.flowable.core.enums.BpmnVariableConstants;
+import com.zt.plat.module.bpm.service.task.BpmProcessInstanceService;
+import org.assertj.core.util.Sets;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BpmTaskCandidateStartUserSelectStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateStartUserSelectStrategy strategy;
+
+    @Mock
+    private BpmProcessInstanceService processInstanceService;
+
+    @Test
+    public void testCalculateUsersByTask() {
+        // 准备参数
+        String param = "2";
+        // mock 方法（获得流程发起人）
+        ProcessInstance processInstance = mock(ProcessInstance.class);
+        DelegateExecution execution = mock(DelegateExecution.class);
+        when(processInstanceService.getProcessInstance(eq(execution.getProcessInstanceId()))).thenReturn(processInstance);
+        when(execution.getCurrentActivityId()).thenReturn("activity_001");
+        // mock 方法（FlowableUtils）
+        Map<String, Object> processVariables = new HashMap<>();
+        processVariables.put(BpmnVariableConstants.PROCESS_INSTANCE_VARIABLE_START_USER_SELECT_ASSIGNEES,
+                MapUtil.of("activity_001", List.of(1L, 2L)));
+        when(processInstance.getProcessVariables()).thenReturn(processVariables);
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByTask(execution, param);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(1L, 2L), userIds);
+    }
+
+    @Test
+    public void testCalculateUsersByActivity() {
+        // 准备参数
+        String activityId = "activity_001";
+        Map<String, Object> processVariables = new HashMap<>();
+        processVariables.put(BpmnVariableConstants.PROCESS_INSTANCE_VARIABLE_START_USER_SELECT_ASSIGNEES,
+                MapUtil.of("activity_001", List.of(1L, 2L)));
+
+        // 调用
+        Set<Long> userIds = strategy.calculateUsersByActivity(null, activityId, null,
+                null, null, processVariables);
+        // 断言
+        assertEquals(Sets.newLinkedHashSet(1L, 2L), userIds);
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/other/BpmTaskCandidateAssignEmptyStrategyTest.java

@@ -0,0 +1,88 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.other;
+
+import cn.hutool.core.collection.ListUtil;
+import com.zt.plat.framework.common.util.collection.SetUtils;
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.bpm.dal.dataobject.definition.BpmProcessDefinitionInfoDO;
+import com.zt.plat.module.bpm.enums.definition.BpmUserTaskAssignEmptyHandlerTypeEnum;
+import com.zt.plat.module.bpm.framework.flowable.core.util.BpmnModelUtils;
+import com.zt.plat.module.bpm.framework.flowable.core.util.FlowableUtils;
+import com.zt.plat.module.bpm.service.definition.BpmProcessDefinitionService;
+import org.flowable.bpmn.model.BpmnModel;
+import org.flowable.bpmn.model.FlowElement;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+
+import java.util.Set;
+
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomPojo;
+import static com.zt.plat.framework.test.core.util.RandomUtils.randomString;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+public class BpmTaskCandidateAssignEmptyStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateAssignEmptyStrategy strategy;
+
+    @Mock
+    private BpmProcessDefinitionService processDefinitionService;
+
+    @Test
+    public void testCalculateUsersByTask() {
+        try (MockedStatic<FlowableUtils> flowableUtilMockedStatic = mockStatic(FlowableUtils.class);
+             MockedStatic<BpmnModelUtils> bpmnModelUtilsMockedStatic = mockStatic(BpmnModelUtils.class)) {
+            // 准备参数
+            DelegateExecution execution = mock(DelegateExecution.class);
+            String param = randomString();
+            // mock 方法（execution）
+            String processDefinitionId = randomString();
+            when(execution.getProcessDefinitionId()).thenReturn(processDefinitionId);
+            FlowElement flowElement = mock(FlowElement.class);
+            when(execution.getCurrentFlowElement()).thenReturn(flowElement);
+            // mock 方法（parseAssignEmptyHandlerType）
+            bpmnModelUtilsMockedStatic.when(() -> BpmnModelUtils.parseAssignEmptyHandlerType(same(flowElement)))
+                    .thenReturn(BpmUserTaskAssignEmptyHandlerTypeEnum.ASSIGN_USER.getType());
+            bpmnModelUtilsMockedStatic.when(() -> BpmnModelUtils.parseAssignEmptyHandlerUserIds(same(flowElement)))
+                    .thenReturn(ListUtil.of(1L, 2L));
+
+            // 调用
+            Set<Long> userIds = strategy.calculateUsersByTask(execution, param);
+            // 断言
+            assertEquals(SetUtils.asSet(1L, 2L), userIds);
+        }
+
+    }
+
+    @Test
+    public void testCalculateUsersByActivity() {
+        try (MockedStatic<BpmnModelUtils> bpmnModelUtilsMockedStatic = mockStatic(BpmnModelUtils.class)) {
+            // 准备参数
+            String processDefinitionId = randomString();
+            String activityId = randomString();
+            String param = randomString();
+            // mock 方法（getFlowElementById）
+            FlowElement flowElement = mock(FlowElement.class);
+            BpmnModel bpmnModel = mock(BpmnModel.class);
+            bpmnModelUtilsMockedStatic.when(() -> BpmnModelUtils.getFlowElementById(same(bpmnModel), eq(activityId)))
+                    .thenReturn(flowElement);
+            // mock 方法（parseAssignEmptyHandlerType）
+            bpmnModelUtilsMockedStatic.when(() -> BpmnModelUtils.parseAssignEmptyHandlerType(same(flowElement)))
+                 .thenReturn(BpmUserTaskAssignEmptyHandlerTypeEnum.ASSIGN_ADMIN.getType());
+            // mock 方法（getProcessDefinitionInfo）
+            BpmProcessDefinitionInfoDO processDefinition = randomPojo(BpmProcessDefinitionInfoDO.class,
+                    o -> o.setManagerUserIds(ListUtil.of(1L, 2L)));
+            when(processDefinitionService.getProcessDefinitionInfo(eq(processDefinitionId))).thenReturn(processDefinition);
+
+            // 调用
+            Set<Long> userIds = strategy.calculateUsersByActivity(bpmnModel, activityId, param,
+                    null, processDefinitionId, null);
+            // 断言
+            assertEquals(SetUtils.asSet(1L, 2L), userIds);
+        }
+    }
+
+}

zt-module-bpm/zt-module-bpm-server/src/test/java/com/zt/plat/module/bpm/framework/flowable/core/candidate/strategy/other/BpmTaskCandidateExpressionStrategyTest.java

@@ -0,0 +1,61 @@
+package com.zt.plat.module.bpm.framework.flowable.core.candidate.strategy.other;
+
+import com.zt.plat.framework.test.core.ut.BaseMockitoUnitTest;
+import com.zt.plat.module.bpm.framework.flowable.core.util.FlowableUtils;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.MockedStatic;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static com.zt.plat.framework.common.util.collection.SetUtils.asSet;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@Disabled // TODO 芋艿：临时注释
+public class BpmTaskCandidateExpressionStrategyTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private BpmTaskCandidateExpressionStrategy strategy;
+
+    @Test
+    public void testCalculateUsersByTask() {
+        try (MockedStatic<FlowableUtils> flowableUtilMockedStatic = mockStatic(FlowableUtils.class)) {
+            // 准备参数
+            String param = "1,2";
+            DelegateExecution execution = mock(DelegateExecution.class);
+            // mock 方法
+            flowableUtilMockedStatic.when(() -> FlowableUtils.getExpressionValue(same(execution), eq(param)))
+                    .thenReturn(asSet(1L, 2L));
+
+            // 调用
+            Set<Long> results = strategy.calculateUsersByTask(execution, param);
+            // 断言
+            assertEquals(asSet(1L, 2L), results);
+        }
+    }
+
+    @Test
+    public void testCalculateUsersByActivity() {
+        try (MockedStatic<FlowableUtils> flowableUtilMockedStatic = mockStatic(FlowableUtils.class)) {
+            // 准备参数
+            String param = "1,2";
+            Map<String, Object> processVariables = new HashMap<>();
+            // mock 方法
+            flowableUtilMockedStatic.when(() -> FlowableUtils.getExpressionValue(same(processVariables), eq(param)))
+                    .thenReturn(asSet(1L, 2L));
+
+            // 调用
+            Set<Long> results = strategy.calculateUsersByActivity(null, null, param,
+                    null, null, processVariables);
+            // 断言
+            assertEquals(asSet(1L, 2L), results);
+        }
+    }
+
+}