package cn.lihu.jh.module.ecg.enums; import org.junit.Test; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import static org.junit.Assert.*; /** * 回归测试:排队序号规则枚举 {@link SeqRuleEnum}。 * *
* counter: 9 → 分配 9 * counter: 10 → nextNormalSeq(10) 期望 11?(错) * counter: 11 → 分配 11 ← 与上一行撞车 ** 正确语义是:**分配号 = {@code nextNormalSeq(counter)},且计数器在"下一个号是预留号"时额外 +1**, * 即 {@code normal_next = normal_next + 1 + (normal_next + 1 是 10 的倍数 ? 1 : 0)}。 */ public class SeqRuleEnumTest { // ---------------------------------------------------------------- 解析 @Test public void testParse_null_shouldFallbackToTimeslot() { assertEquals(SeqRuleEnum.TIMESLOT, SeqRuleEnum.parse(null)); } @Test public void testParse_unknownValue_shouldFallbackToTimeslot() { assertEquals(SeqRuleEnum.TIMESLOT, SeqRuleEnum.parse(99)); assertEquals(SeqRuleEnum.TIMESLOT, SeqRuleEnum.parse(-1)); } @Test public void testParse_knownValues() { assertEquals(SeqRuleEnum.APPOINT, SeqRuleEnum.parse(0)); assertEquals(SeqRuleEnum.CHECKIN, SeqRuleEnum.parse(1)); assertEquals(SeqRuleEnum.TIMESLOT, SeqRuleEnum.parse(2)); } // ------------------------------------------------------- 容量语义差异 @Test public void testIsCapacityLimited_onlyTimeslot() { assertFalse(SeqRuleEnum.APPOINT.isCapacityLimited()); assertFalse(SeqRuleEnum.CHECKIN.isCapacityLimited()); assertTrue(SeqRuleEnum.TIMESLOT.isCapacityLimited()); } // ---------------------------------------------------------- 预留号判定 @Test public void testIsReservedSeq() { assertTrue(SeqRuleEnum.isReservedSeq(10)); assertTrue(SeqRuleEnum.isReservedSeq(20)); assertTrue(SeqRuleEnum.isReservedSeq(100)); assertFalse(SeqRuleEnum.isReservedSeq(1)); assertFalse(SeqRuleEnum.isReservedSeq(9)); assertFalse(SeqRuleEnum.isReservedSeq(11)); assertFalse(SeqRuleEnum.isReservedSeq(0)); assertFalse(SeqRuleEnum.isReservedSeq(-10)); } @Test public void testRoundSize_matchesReservedRule() { assertEquals(10, SeqRuleEnum.ROUND_SIZE); assertEquals(1, SeqRuleEnum.RESERVED_PER_ROUND); // 「每 9 个号预留 1 个」= 9 普通 + 1 预留 = 一轮 10 个 assertEquals(SeqRuleEnum.ROUND_SIZE, 9 + SeqRuleEnum.RESERVED_PER_ROUND); } // -------------------------------------------------------- 普通号序列 @Test public void testNextNormalSeq_shouldReturnNonReservedValue() { // 直接语义:返回 from 起第一个非预留号(10 本身是预留号 → 返回 11) assertEquals(1, SeqRuleEnum.nextNormalSeq(1)); assertEquals(9, SeqRuleEnum.nextNormalSeq(9)); assertEquals("10 是预留号,应跳到 11", 11, SeqRuleEnum.nextNormalSeq(10)); assertEquals(11, SeqRuleEnum.nextNormalSeq(11)); assertEquals(19, SeqRuleEnum.nextNormalSeq(19)); assertEquals(21, SeqRuleEnum.nextNormalSeq(20)); assertEquals("99 本身不是预留号,原样返回", 99, SeqRuleEnum.nextNormalSeq(99)); assertEquals("100 是预留号,跳到 101", 101, SeqRuleEnum.nextNormalSeq(100)); } /** * 端到端模拟 Mapper 的推进公式,验证**连续 30 次普通取号不重号、不跳号**。 * *
公式与 {@code QueueSequenceMapper#advanceNormalSeq} 完全一致: *
* INSERT 时 normal_next = 1
* UPDATE 时 normal_next = normal_next + 1 + IF((normal_next + 1) % 10 = 0, 1, 0)
* 分配号 = nextNormalSeq(normal_next - 上次推进量)? —— 不对,
* 实际是:分配号由「读回后的 normal_next」经 nextNormalSeq 得到
*
* 这里用最直白的方式还原:维护 {@code lastAssigned},每次
* {@code next = lastAssigned + 1},若是预留号则 {@code next++}(跳过),
* 然后 {@code lastAssigned = next}。
*/
@Test
public void testNormalSequence_isContiguousAndSkipsReserved() {
List若只用一个递增计数器、并把"跳过预留号"后的值直接当号码用, * 会在 counter=10 与 counter=11 两次分配中得到同一个号 11。 */ @Test public void testSingleCounterNaiveApproach_wouldCollide_documentingWhyTwoCounters() { assertEquals("counter=10 时跳过预留号得到 11", 11, SeqRuleEnum.nextNormalSeq(10)); assertEquals("counter=11 时直接得到 11", 11, SeqRuleEnum.nextNormalSeq(11)); assertEquals("两者相同 → 朴素做法必然重号", SeqRuleEnum.nextNormalSeq(10), SeqRuleEnum.nextNormalSeq(11)); } // ------------------------------------------------------------- 数组 @Test public void testArrays_containsAllRules() { int[] arrays = SeqRuleEnum.ARRAYS; assertEquals(3, arrays.length); assertEquals(0, arrays[0]); assertEquals(1, arrays[1]); assertEquals(2, arrays[2]); } }