【feat】【v3】

1.修复单元测试中发现的问题
2.增加测试用例

src/main/java/com/punchsettle/server/atomic/entity/PiMultiTaskExt.java

@@ -6,6 +6,7 @@ import java.io.Serializable;
 import com.punchsettle.server.atomic.TaskExt;
 import com.punchsettle.server.common.pojo.BaseEntity;
 
+import com.punchsettle.server.constant.PunchInDimensionEnum;
 import jakarta.persistence.Column;
 import jakarta.persistence.Table;
 import lombok.Data;
@@ -39,9 +40,10 @@ public class PiMultiTaskExt extends BaseEntity implements Serializable, TaskExt
 
     /**
      * 使用维度（一天-ONE_DAY，多天-MULTI_DAY）
+     * @see PunchInDimensionEnum
      */
     @Column(name = "dimension")
-    private String dimension;
+    private PunchInDimensionEnum dimension;
 
     /**
      * 起始值（单位：次）

src/main/java/com/punchsettle/server/service/manager/impl/SettleManagerImpl.java

@@ -169,11 +169,14 @@ public class SettleManagerImpl implements ISettleManager {
         int basicPoints = piMultiTask.getPoints();
 
         // 额外积分
-        List<TaskExt> punchInTaskOneExtList = piMultiTaskExtList.stream()
-            .filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
-        // 额外次数
-        int extractCount = piMultiTaskHistory.getPunchInDoneCount() - piMultiTask.getPunchInDoneCount();
-        int extraPoints = calculateExtraPoints(piMultiTask.getExtraMethod(), extractCount, piMultiTask.getExtraPoints(), punchInTaskOneExtList);
+        int extraPoints = 0;
+        if (!PunchInExtraMethodEnum.NONE.equals(piMultiTask.getExtraMethod())) {
+            List<TaskExt> punchInTaskOneExtList = piMultiTaskExtList.stream()
+                    .filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
+            // 额外次数
+            int extractCount = piMultiTaskHistory.getPunchInDoneCount() - piMultiTask.getPunchInDoneCount();
+            extraPoints = calculateExtraPoints(piMultiTask.getExtraMethod(), extractCount, piMultiTask.getExtraPoints(), punchInTaskOneExtList);
+        }
 
         // 连续完成额外积分
         List<TaskExt> punchInTaskMultiExtList = piMultiTaskExtList.stream()
@@ -240,6 +243,7 @@ public class SettleManagerImpl implements ISettleManager {
      * @return
      */
     private int calculateIntervalPoints(Integer extraCount, List<TaskExt> taskExtList) {
+        extraCount = Optional.ofNullable(extraCount).orElse(0);
         // 积分
         int points = 0;
         // 第二轮标志

src/test/java/com/punchsettle/server/service/manager/impl/SettleManagerImplTest.java

@@ -0,0 +1,461 @@
+package com.punchsettle.server.service.manager.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
+import com.punchsettle.server.constant.ContinueStatusEnum;
+import com.punchsettle.server.constant.FullAttendancePeriodEnum;
+import com.punchsettle.server.constant.PunchInDimensionEnum;
+import com.punchsettle.server.constant.PunchInExtraMethodEnum;
+import com.punchsettle.server.constant.PunchInMethodEnum;
+import com.punchsettle.server.constant.PunchInResultEnum;
+import com.punchsettle.server.service.manager.ISettleManager;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/23 18:38
+ * @description TODO
+ */
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(value={"dev", "test"})
+class SettleManagerImplTest {
+
+    @Autowired
+    private ISettleManager settleManager;
+
+    /**
+     * 测试未完成打卡
+     */
+    @Test
+    void calculatePointsInTask1() {
+        PiTaskHistory piTaskHistory1 = new PiTaskHistory();
+        piTaskHistory1.setPunchInResult(PunchInResultEnum.UNDONE);
+        int points1 = settleManager.calculatePointsInTask(null, null, piTaskHistory1, null);
+        Assertions.assertEquals(0, points1);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励
+     */
+    @Test
+    void calculatePointsInTask2() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+
+        PiTaskHistory piTaskHistory = new PiTaskHistory();
+        piTaskHistory.setCountTrack(5);
+        piTaskHistory.setPunchInDate("2025-04-23");
+        piTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+        int points = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory, null);
+
+        Assertions.assertEquals(10, points);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+额外固定奖励
+     */
+    @Test
+    void calculatePointsInTask3() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.FIXED);
+        piTask.setExtraPoints(5);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+
+        PiTaskHistory piTaskHistory = new PiTaskHistory();
+        piTaskHistory.setCountTrack(6);
+        piTaskHistory.setPunchInDate("2025-04-23");
+        piTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+        int points = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory, null);
+
+        Assertions.assertEquals(15, points);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+额外区间奖励
+     */
+    @Test
+    void calculatePointsInTask4() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.INTERVAL);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+
+        List<PiTaskExt> piTaskExtList = buildTaskExt();
+
+        PiTaskHistory piTaskHistory = new PiTaskHistory();
+        piTaskHistory.setCountTrack(17);
+        piTaskHistory.setPunchInDate("2025-04-23");
+        piTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+        int points = settleManager.calculatePointsInTask(piTask, piTaskExtList, piTaskHistory, null);
+
+        Assertions.assertEquals(60, points);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+节假日双倍
+     */
+    @Test
+    void calculatePointsInTask5() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.ENABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setHolidayCountTrack(3);
+
+        // 工作日
+        PiTaskHistory piTaskHistory1 = new PiTaskHistory();
+        piTaskHistory1.setCountTrack(5);
+        piTaskHistory1.setPunchInDate("2025-04-23");
+        piTaskHistory1.setPunchInResult(PunchInResultEnum.DONE);
+        int points1 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory1, null);
+        Assertions.assertEquals(10, points1);
+
+        // 节假日
+        PiTaskHistory piTaskHistory2 = new PiTaskHistory();
+        piTaskHistory2.setCountTrack(5);
+        piTaskHistory2.setPunchInDate("2025-04-23");
+        piTaskHistory2.setPunchInResult(PunchInResultEnum.DONE);
+        int points2 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory2, null);
+        Assertions.assertEquals(10, points2);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+全勤双倍（周）
+     */
+    @Test
+    void calculatePointsInTask6() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.ENABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendancePeriod(FullAttendancePeriodEnum.WEEK);
+        piTask.setFullAttendanceFaultToleranceCnt(2);
+
+        // 满足全勤，但结算日期不是周日
+        PiStatus piStatus1 = new PiStatus();
+        piStatus1.setPunchInTotalCountInWeek(7);
+        piStatus1.setPunchInDoneCountInWeek(5);
+
+        PiTaskHistory piTaskHistory1 = new PiTaskHistory();
+        piTaskHistory1.setCountTrack(5);
+        piTaskHistory1.setPunchInDate("2025-04-23");
+        piTaskHistory1.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points1 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory1, piStatus1);
+        Assertions.assertEquals(10, points1);
+
+        // 满足全勤，结算日期是周日
+        PiStatus piStatus2 = new PiStatus();
+        piStatus2.setPunchInTotalCountInWeek(7);
+        piStatus2.setPunchInDoneCountInWeek(5);
+
+        PiTaskHistory piTaskHistory2 = new PiTaskHistory();
+        piTaskHistory2.setCountTrack(5);
+        piTaskHistory2.setPunchInDate("2025-04-27");
+        piTaskHistory2.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points2 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory2, piStatus2);
+        Assertions.assertEquals(20, points2);
+
+        // 不满足全勤，结算日期是周日
+        PiStatus piStatus3 = new PiStatus();
+        piStatus3.setPunchInTotalCountInWeek(7);
+        piStatus3.setPunchInDoneCountInWeek(2);
+
+        PiTaskHistory piTaskHistory3 = new PiTaskHistory();
+        piTaskHistory3.setCountTrack(5);
+        piTaskHistory3.setPunchInDate("2025-04-27");
+        piTaskHistory3.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points3 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory3, piStatus3);
+        Assertions.assertEquals(10, points3);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+全勤双倍（月）
+     */
+    @Test
+    void calculatePointsInTask7() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.ENABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendancePeriod(FullAttendancePeriodEnum.MONTH);
+        piTask.setFullAttendanceFaultToleranceCnt(2);
+
+        // 满足全勤，但结算日期不是月末
+        PiStatus piStatus1 = new PiStatus();
+        piStatus1.setPunchInTotalCountInMonth(7);
+        piStatus1.setPunchInDoneCountInMonth(5);
+
+        PiTaskHistory piTaskHistory1 = new PiTaskHistory();
+        piTaskHistory1.setCountTrack(5);
+        piTaskHistory1.setPunchInDate("2025-04-23");
+        piTaskHistory1.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points1 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory1, piStatus1);
+        Assertions.assertEquals(10, points1);
+
+        // 满足全勤，结算日期是月末
+        PiStatus piStatus2 = new PiStatus();
+        piStatus2.setPunchInTotalCountInMonth(7);
+        piStatus2.setPunchInDoneCountInMonth(5);
+
+        PiTaskHistory piTaskHistory2 = new PiTaskHistory();
+        piTaskHistory2.setCountTrack(5);
+        piTaskHistory2.setPunchInDate("2025-04-30");
+        piTaskHistory2.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points2 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory2, piStatus2);
+        Assertions.assertEquals(20, points2);
+
+        // 不满足全勤，结算日期是月末
+        PiStatus piStatus3 = new PiStatus();
+        piStatus3.setPunchInTotalCountInMonth(7);
+        piStatus3.setPunchInDoneCountInMonth(2);
+
+        PiTaskHistory piTaskHistory3 = new PiTaskHistory();
+        piTaskHistory3.setCountTrack(5);
+        piTaskHistory3.setPunchInDate("2025-04-30");
+        piTaskHistory3.setPunchInResult(PunchInResultEnum.DONE);
+
+        int points3 = settleManager.calculatePointsInTask(piTask, List.of(), piTaskHistory3, piStatus3);
+        Assertions.assertEquals(10, points3);
+    }
+
+    /**
+     * 测试 完成打卡，获得基本奖励+连续任务奖励
+     */
+    @Test
+    void calculatePointsInTask8() {
+        PiTask piTask = new PiTask();
+        piTask.setPoints(10);
+        piTask.setPunchInMethod(PunchInMethodEnum.COUNT);
+        piTask.setCountTrack(5);
+        piTask.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piTask.setHolidayStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setFullAttendanceStatus(CommonEnableStatusEnum.DISABLED);
+        piTask.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+
+        PiTaskHistory piTaskHistory = new PiTaskHistory();
+        piTaskHistory.setCountTrack(5);
+        piTaskHistory.setPunchInDate("2025-04-23");
+        piTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+
+        List<PiTaskExt> piTaskExtList = buildTaskExt();
+
+        // 连续打卡
+        PiStatus piStatus1 = new PiStatus();
+        piStatus1.setTaskContinueStatus(ContinueStatusEnum.CONTINUE);
+        piStatus1.setTaskContinueDay(12);
+        int points1 = settleManager.calculatePointsInTask(piTask, piTaskExtList, piTaskHistory, piStatus1);
+        Assertions.assertEquals(60, points1);
+
+        // 打卡中断
+        PiStatus piStatus2 = new PiStatus();
+        piStatus2.setTaskContinueStatus(ContinueStatusEnum.INTERRUPTED);
+        piStatus2.setTaskContinueDay(12);
+        int points2 = settleManager.calculatePointsInTask(piTask, piTaskExtList, piTaskHistory, piStatus2);
+        Assertions.assertEquals(10, points2);
+    }
+
+    /**
+     * 测试未完成打卡、未启用任务积分计算
+     */
+    @Test
+    void calculatePointsInMultiTask() {
+        PiMultiTask piMultiTask1 = new PiMultiTask();
+        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.DISABLED);
+        PiMultiTaskHistory piMultiTaskHistory1 = new PiMultiTaskHistory();
+        piMultiTaskHistory1.setPunchInResult(PunchInResultEnum.DONE);
+        int points1 = settleManager.calculatePointsInMultiTask(piMultiTask1, null, piMultiTaskHistory1, null);
+        Assertions.assertEquals(0, points1);
+
+        PiMultiTask piMultiTask2 = new PiMultiTask();
+        piMultiTask2.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+        PiMultiTaskHistory piMultiTaskHistory2 = new PiMultiTaskHistory();
+        piMultiTaskHistory2.setPunchInResult(PunchInResultEnum.UNDONE);
+        int points2 = settleManager.calculatePointsInMultiTask(piMultiTask2, null, piMultiTaskHistory2, null);
+        Assertions.assertEquals(0, points2);
+    }
+
+    /**
+     * 测试获取基本积分+额外固定积分
+     */
+    @Test
+    void calculatePointsInMultiTask2() {
+        PiMultiTask piMultiTask1 = new PiMultiTask();
+        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+        piMultiTask1.setPoints(10);
+        piMultiTask1.setExtraMethod(PunchInExtraMethodEnum.FIXED);
+        piMultiTask1.setExtraPoints(5);
+        piMultiTask1.setPunchInDoneCount(5);
+
+        PiMultiTaskHistory piMultiTaskHistory = new PiMultiTaskHistory();
+        piMultiTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+        piMultiTaskHistory.setPunchInDoneCount(6);
+
+        PiStatus piStatus = new PiStatus();
+
+        int points = settleManager.calculatePointsInMultiTask(piMultiTask1, List.of(), piMultiTaskHistory, piStatus);
+        Assertions.assertEquals(15, points);
+    }
+
+    /**
+     * 测试获取基本积分+额外区间积分
+     */
+    @Test
+    void calculatePointsInMultiTask3() {
+        PiMultiTask piMultiTask1 = new PiMultiTask();
+        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+        piMultiTask1.setPoints(10);
+        piMultiTask1.setExtraMethod(PunchInExtraMethodEnum.INTERVAL);
+        piMultiTask1.setPunchInDoneCount(5);
+
+        PiMultiTaskHistory piMultiTaskHistory = new PiMultiTaskHistory();
+        piMultiTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+        piMultiTaskHistory.setPunchInDoneCount(17);
+
+        List<PiMultiTaskExt> piTaskExtList = buildMultiTaskExt();
+
+        PiStatus piStatus = new PiStatus();
+        int points = settleManager.calculatePointsInMultiTask(piMultiTask1, piTaskExtList, piMultiTaskHistory, piStatus);
+        Assertions.assertEquals(60, points);
+    }
+
+    /**
+     * 测试获取基本积分+连续完成积分
+     */
+    @Test
+    void calculatePointsInMultiTask4() {
+        List<PiMultiTaskExt> piTaskExtList = buildMultiTaskExt();
+
+        PiMultiTask piMultiTask1 = new PiMultiTask();
+        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+        piMultiTask1.setPoints(10);
+        piMultiTask1.setExtraMethod(PunchInExtraMethodEnum.NONE);
+        piMultiTask1.setTaskPointsStatus(CommonEnableStatusEnum.ENABLED);
+
+        PiMultiTaskHistory piMultiTaskHistory = new PiMultiTaskHistory();
+        piMultiTaskHistory.setPunchInResult(PunchInResultEnum.DONE);
+
+        PiStatus piStatus1 = new PiStatus();
+        piStatus1.setTaskContinueStatus(ContinueStatusEnum.CONTINUE);
+        piStatus1.setTaskContinueDay(12);
+
+        int points1 = settleManager.calculatePointsInMultiTask(piMultiTask1, piTaskExtList, piMultiTaskHistory, piStatus1);
+        Assertions.assertEquals(60, points1);
+    }
+
+
+    private List<PiTaskExt> buildTaskExt() {
+        List<PiTaskExt> piTaskExtList1 = buildTaskExt(PunchInDimensionEnum.MULTI_DAY);
+        List<PiTaskExt> piTaskExtList2 = buildTaskExt(PunchInDimensionEnum.ONE_DAY);
+
+        List<PiTaskExt> list = new ArrayList<>();
+        list.addAll(piTaskExtList1);
+        list.addAll(piTaskExtList2);
+        return list;
+    }
+
+    private List<PiTaskExt> buildTaskExt(PunchInDimensionEnum punchInDimension) {
+        PiTaskExt piTaskExt1 = new PiTaskExt();
+        piTaskExt1.setInitialValue(1);
+        piTaskExt1.setExtraPoints(1);
+        piTaskExt1.setDimension(punchInDimension);
+
+        PiTaskExt piTaskExt2 = new PiTaskExt();
+        piTaskExt2.setInitialValue(6);
+        piTaskExt2.setExtraPoints(5);
+        piTaskExt2.setDimension(punchInDimension);
+
+        PiTaskExt piTaskExt3 = new PiTaskExt();
+        piTaskExt3.setInitialValue(11);
+        piTaskExt3.setExtraPoints(10);
+        piTaskExt3.setDimension(punchInDimension);
+
+        PiTaskExt piTaskExt4 = new PiTaskExt();
+        piTaskExt4.setInitialValue(15);
+        piTaskExt4.setExtraPoints(15);
+        piTaskExt4.setDimension(punchInDimension);
+
+        return Arrays.asList(piTaskExt1, piTaskExt2, piTaskExt3, piTaskExt4);
+    }
+
+    private List<PiMultiTaskExt> buildMultiTaskExt() {
+        List<PiMultiTaskExt> piTaskExtList1 = buildMultiTaskExt(PunchInDimensionEnum.MULTI_DAY);
+        List<PiMultiTaskExt> piTaskExtList2 = buildMultiTaskExt(PunchInDimensionEnum.ONE_DAY);
+
+        List<PiMultiTaskExt> list = new ArrayList<>();
+        list.addAll(piTaskExtList1);
+        list.addAll(piTaskExtList2);
+        return list;
+    }
+
+    private List<PiMultiTaskExt> buildMultiTaskExt(PunchInDimensionEnum punchInDimension) {
+        PiMultiTaskExt piTaskExt1 = new PiMultiTaskExt();
+        piTaskExt1.setInitialValue(1);
+        piTaskExt1.setExtraPoints(1);
+        piTaskExt1.setDimension(punchInDimension);
+
+        PiMultiTaskExt piTaskExt2 = new PiMultiTaskExt();
+        piTaskExt2.setInitialValue(6);
+        piTaskExt2.setExtraPoints(5);
+        piTaskExt2.setDimension(punchInDimension);
+
+        PiMultiTaskExt piTaskExt3 = new PiMultiTaskExt();
+        piTaskExt3.setInitialValue(11);
+        piTaskExt3.setExtraPoints(10);
+        piTaskExt3.setDimension(punchInDimension);
+
+        PiMultiTaskExt piTaskExt4 = new PiMultiTaskExt();
+        piTaskExt4.setInitialValue(15);
+        piTaskExt4.setExtraPoints(15);
+        piTaskExt4.setDimension(punchInDimension);
+
+        return Arrays.asList(piTaskExt1, piTaskExt2, piTaskExt3, piTaskExt4);
+    }
+}