@operato/scene-storage 10.0.0-beta.41 → 10.0.0-beta.43

package/test/test-rack-grid-location.ts

@@ -0,0 +1,657 @@
+/*
+ * RackGrid — location 룰 / cellOverrides / bulk 편집 단위 테스트.
+ *
+ * 검증 대상:
+ *  - locationOf / cellIdOfLocation 양방향 변환 (룰만, override 없는 경우 null)
+ *  - cellOverrides 의 section/unit 명시되어야 location 부여 (B 정책)
+ *  - shelfLabels (shelfLocations 의 빈 자리 1-based fallback)
+ *  - locPattern 변경 시 location 표현 갱신 + cellId 안정
+ *  - isEmpty cell 의 location 미부여
+ *  - bulk: setCellOverride / clearCellOverride / setIsEmpty / setBorder
+ *  - increaseLocation: cw/ccw/zigzag/zigzag-reverse, skipNumbering, aisle 분리
+ *
+ * 진짜 RackGrid 인스턴스화는 things-scene full pipeline 필요해서 비현실적. 기존
+ * MiniRack 패턴처럼 *알고리즘 인라인 재구현* 한 MiniGrid 로 검증 — RackGrid 의 진짜
+ * 알고리즘이 동일한지는 *시각적 코드 리뷰 + 빌드* + *통합 테스트* 로 보완.
+ */
+
+import 'should'
+
+// ── Fixture: RackGrid 의 핵심 알고리즘만 격리한 MiniGrid ──────────────────────
+
+interface CellOverride {
+  section?: string
+  unit?: string
+  isEmpty?: boolean
+  border?: any
+  merged?: boolean
+}
+
+class MiniGrid {
+  state: any
+  private _locationIndexCache?: Map<string, string>
+
+  constructor(initialState: any = {}) {
+    this.state = {
+      columns: 5,
+      rows: 1,
+      shelves: 4,
+      sectionDigits: 2,
+      unitDigits: 2,
+      locPattern: '{z}{s}-{u}-{sh}',
+      zone: 'Z',
+      cellOverrides: {},
+      ...initialState
+    }
+  }
+
+  setState(partial: any) {
+    this.state = { ...this.state, ...partial }
+    // RackGrid 의 onchange* 콜백 시뮬
+    if ('cellOverrides' in partial || 'locPattern' in partial ||
+        'shelfLocations' in partial || 'zone' in partial ||
+        'sectionDigits' in partial || 'unitDigits' in partial ||
+        'shelves' in partial) {
+      this._locationIndexCache = undefined
+    }
+  }
+
+  get columns(): number { return Math.max(1, Math.floor(this.state.columns ?? 5)) }
+  get rackRows(): number { return Math.max(1, Math.floor(this.state.rows ?? 1)) }
+  get shelves(): number { return Math.max(1, Math.floor(this.state.shelves ?? 4)) }
+  get cellOverrides(): { [posKey: string]: CellOverride } { return this.state.cellOverrides ?? {} }
+
+  get shelfLabels(): string[] {
+    const input = this.state.shelfLocations
+    const levels = this.shelves
+    const parts = (input || '').split(',')
+    const out: string[] = []
+    for (let i = 0; i < levels; i++) {
+      const p = parts[i]
+      out[i] = p && p.trim().length > 0 ? p.trim() : String(i + 1)
+    }
+    return out
+  }
+
+  parseCellId(cellId: string): { col: number; row: number; shelf: number } | null {
+    const parts = cellId.split('-')
+    if (parts.length !== 3) return null
+    const [c, r, s] = parts.map(Number)
+    if (!Number.isFinite(c) || !Number.isFinite(r) || !Number.isFinite(s)) return null
+    return { col: c, row: r, shelf: s }
+  }
+
+  parsePosKey(posKey: string): { col: number; row: number } | null {
+    const parts = posKey.split('-')
+    if (parts.length !== 2) return null
+    const [c, r] = parts.map(Number)
+    if (!Number.isFinite(c) || !Number.isFinite(r)) return null
+    return { col: c, row: r }
+  }
+
+  locationOf(cellId: string): string | null {
+    const parsed = this.parseCellId(cellId)
+    if (!parsed) return null
+    const posKey = `${parsed.col}-${parsed.row}`
+    const override = this.cellOverrides[posKey]
+    if (!override?.section || !override?.unit || override.isEmpty) return null
+
+    const pattern = this.state.locPattern ?? '{z}{s}-{u}-{sh}'
+    const zone = this.state.zone ?? ''
+    const shelfLabel = this.shelfLabels[parsed.shelf] ?? String(parsed.shelf + 1)
+
+    return pattern
+      .replace(/\{z\}/g, zone)
+      .replace(/\{s\}/g, override.section)
+      .replace(/\{u\}/g, override.unit)
+      .replace(/\{sh\}/g, shelfLabel)
+  }
+
+  cellIdOfLocation(location: string): string | null {
+    return this._locationIndex.get(location) ?? null
+  }
+
+  private get _locationIndex(): Map<string, string> {
+    if (this._locationIndexCache) return this._locationIndexCache
+    const map = new Map<string, string>()
+    const overrides = this.cellOverrides
+    const shelves = this.shelves
+    for (const posKey of Object.keys(overrides)) {
+      const override = overrides[posKey]
+      if (!override.section || !override.unit || override.isEmpty) continue
+      const parsed = this.parsePosKey(posKey)
+      if (!parsed) continue
+      for (let shelfIdx = 0; shelfIdx < shelves; shelfIdx++) {
+        const cellId = `${parsed.col}-${parsed.row}-${shelfIdx}`
+        const loc = this.locationOf(cellId)
+        if (loc) map.set(loc, cellId)
+      }
+    }
+    this._locationIndexCache = map
+    return map
+  }
+
+  setCellOverride(posKey: string, partial: Partial<CellOverride>): void {
+    const current = this.cellOverrides
+    const existing = current[posKey] ?? {}
+    const merged: any = { ...existing }
+    for (const [k, v] of Object.entries(partial)) {
+      if (v === undefined) delete merged[k]
+      else merged[k] = v
+    }
+    const next = { ...current }
+    if (Object.keys(merged).length === 0) delete next[posKey]
+    else next[posKey] = merged
+    this.setState({ cellOverrides: next })
+  }
+
+  clearCellOverride(posKey: string): void {
+    const current = this.cellOverrides
+    if (!(posKey in current)) return
+    const next = { ...current }
+    delete next[posKey]
+    this.setState({ cellOverrides: next })
+  }
+
+  setIsEmpty(posKeys: string[], isEmpty: boolean): void {
+    const current = this.cellOverrides
+    const next = { ...current }
+    for (const posKey of posKeys) {
+      const existing = next[posKey] ?? {}
+      const merged: any = { ...existing, isEmpty }
+      if (!isEmpty && !existing.section && !existing.unit && !existing.border && !existing.merged) {
+        delete next[posKey]
+      } else {
+        next[posKey] = merged
+      }
+    }
+    this.setState({ cellOverrides: next })
+  }
+
+  setBorder(posKeys: string[], style: any, where: 'all' | 'top' | 'left' | 'bottom' | 'right' = 'all'): void {
+    const sides = where === 'all' ? ['top', 'left', 'bottom', 'right'] : [where]
+    const current = this.cellOverrides
+    const next = { ...current }
+    for (const posKey of posKeys) {
+      const existing = next[posKey] ?? {}
+      const border = { ...(existing.border ?? {}) }
+      for (const side of sides) {
+        if (style == null) delete border[side]
+        else border[side] = style
+      }
+      const merged: any = { ...existing, border }
+      if (Object.keys(border).length === 0) delete merged.border
+      next[posKey] = merged
+    }
+    this.setState({ cellOverrides: next })
+  }
+
+  increaseLocation(
+    posKeys: string[],
+    direction: 'cw' | 'ccw' | 'zigzag' | 'zigzag-reverse' = 'cw',
+    skipNumbering: boolean = false,
+    startSection: number = 1,
+    startUnit: number = 1
+  ): void {
+    const sectionDigits = Math.max(1, Math.floor(this.state.sectionDigits ?? 2))
+    const unitDigits = Math.max(1, Math.floor(this.state.unitDigits ?? 2))
+
+    const targets: string[] = posKeys.length > 0 ? [...posKeys] : this._allPosKeys()
+
+    const byRow: (string | null)[][] = []
+    let maxRow = -1
+    let maxCol = -1
+    for (const posKey of targets) {
+      const parsed = this.parsePosKey(posKey)
+      if (!parsed) continue
+      if (!byRow[parsed.row]) byRow[parsed.row] = []
+      byRow[parsed.row][parsed.col] = posKey
+      if (parsed.row > maxRow) maxRow = parsed.row
+      if (parsed.col > maxCol) maxCol = parsed.col
+    }
+
+    const overrides = this.cellOverrides
+    const isAisleRow = (row: number): boolean => {
+      const cells = byRow[row]
+      if (!cells || cells.length === 0) return true
+      return cells.every(p => p == null || overrides[p]?.isEmpty === true)
+    }
+
+    const sections: number[][] = []
+    let currentSection: number[] = []
+    for (let r = 0; r <= maxRow; r++) {
+      if (!byRow[r]) continue
+      if (isAisleRow(r)) {
+        if (currentSection.length > 0) { sections.push(currentSection); currentSection = [] }
+      } else {
+        currentSection.push(r)
+      }
+    }
+    if (currentSection.length > 0) sections.push(currentSection)
+
+    const next = { ...overrides }
+    let sectionNum = Number(startSection) || 1
+
+    const setSU = (posKey: string, section: number, unit: number) => {
+      const existing = next[posKey] ?? {}
+      next[posKey] = {
+        ...existing,
+        section: String(section).padStart(sectionDigits, '0'),
+        unit: String(unit).padStart(unitDigits, '0')
+      }
+    }
+    const clearSU = (posKey: string) => {
+      const existing = next[posKey]
+      if (!existing) return
+      const { section, unit, ...rest } = existing
+      if (Object.keys(rest).length === 0) delete next[posKey]
+      else next[posKey] = rest
+    }
+
+    for (const sectionRows of sections) {
+      for (const row of sectionRows) {
+        const cells = byRow[row]
+        if (!cells) continue
+        const orderedCols = this._orderCols(row, sectionRows, direction, maxCol)
+        let unitNum = Number(startUnit) || 1
+        for (const col of orderedCols) {
+          const posKey = cells[col]
+          if (!posKey) continue
+          const isEmpty = overrides[posKey]?.isEmpty === true
+          if (isEmpty) {
+            clearSU(posKey)
+            if (!skipNumbering) unitNum++
+          } else {
+            setSU(posKey, sectionNum, unitNum)
+            unitNum++
+          }
+        }
+      }
+      sectionNum++
+    }
+
+    this.setState({ cellOverrides: next })
+  }
+
+  private _allPosKeys(): string[] {
+    const cols = this.columns
+    const rows = this.rackRows
+    const out: string[] = []
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        out.push(`${c}-${r}`)
+      }
+    }
+    return out
+  }
+
+  private _orderCols(
+    row: number,
+    sectionRows: number[],
+    direction: 'cw' | 'ccw' | 'zigzag' | 'zigzag-reverse',
+    maxCol: number
+  ): number[] {
+    const idxInSection = sectionRows.indexOf(row)
+    const cols: number[] = []
+    for (let c = 0; c <= maxCol; c++) cols.push(c)
+
+    switch (direction) {
+      case 'cw': return idxInSection % 2 === 0 ? cols : cols.slice().reverse()
+      case 'ccw': return idxInSection % 2 === 0 ? cols.slice().reverse() : cols
+      case 'zigzag': return cols
+      case 'zigzag-reverse': return cols.slice().reverse()
+    }
+  }
+}
+
+// ── Group 1: shelfLabels ────────────────────────────────────────────────────
+
+describe('RackGrid: shelfLabels', () => {
+  it('shelfLocations 미지정 → 1-based 인덱스 default', () => {
+    new MiniGrid({ shelves: 4 }).shelfLabels.should.deepEqual(['1', '2', '3', '4'])
+  })
+  it('완전 명시 라벨 그대로', () => {
+    new MiniGrid({ shelves: 3, shelfLocations: 'A,B,C' }).shelfLabels.should.deepEqual(['A', 'B', 'C'])
+  })
+  it('빈 자리는 default 로 fallback', () => {
+    new MiniGrid({ shelves: 4, shelfLocations: ',,,04' }).shelfLabels.should.deepEqual(['1', '2', '3', '04'])
+  })
+  it('입력 길이가 shelves 보다 짧으면 나머지 default', () => {
+    new MiniGrid({ shelves: 4, shelfLocations: 'A,B' }).shelfLabels.should.deepEqual(['A', 'B', '3', '4'])
+  })
+})
+
+// ── Group 2: locationOf — override 없으면 null (B 정책) ────────────────────
+
+describe('RackGrid: locationOf', () => {
+  it('cellOverrides 비었으면 모든 cell location null', () => {
+    const g = new MiniGrid()
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+    ;(g.locationOf('2-0-3') === null).should.be.true()
+  })
+
+  it('section/unit 명시된 cell 만 location 부여', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.locationOf('0-0-0').should.equal('Z01-01-1')
+    g.locationOf('0-0-1').should.equal('Z01-01-2')
+    g.locationOf('0-0-3').should.equal('Z01-01-4')
+    ;(g.locationOf('1-0-0') === null).should.be.true()
+  })
+
+  it('section 만 명시 / unit 만 명시 → 부여 안됨', () => {
+    const g = new MiniGrid({
+      cellOverrides: {
+        '0-0': { section: '01' },
+        '1-0': { unit: '05' }
+      }
+    })
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+    ;(g.locationOf('1-0-0') === null).should.be.true()
+  })
+
+  it('isEmpty cell 은 section/unit 있어도 location null', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01', isEmpty: true } }
+    })
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+  })
+
+  it('shelfLocations 가 location 의 {sh} 에 반영', () => {
+    const g = new MiniGrid({
+      shelves: 4,
+      shelfLocations: 'A,B,C,D',
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.locationOf('0-0-0').should.equal('Z01-01-A')
+    g.locationOf('0-0-3').should.equal('Z01-01-D')
+  })
+
+  it('locPattern 변경 → 표현만 바뀜 (cellId 안정)', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '02' } }
+    })
+    g.locationOf('0-0-0').should.equal('Z01-02-1')
+    g.setState({ locPattern: '{z}-{s}.{u}.{sh}' })
+    g.locationOf('0-0-0').should.equal('Z-01.02.1')
+  })
+})
+
+// ── Group 3: cellIdOfLocation — 역변환 + sparse index ──────────────────────
+
+describe('RackGrid: cellIdOfLocation', () => {
+  it('등록 안된 location → null', () => {
+    ;(new MiniGrid().cellIdOfLocation('Z01-01-1') === null).should.be.true()
+  })
+
+  it('section/unit override 등록 후 역변환 성공', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+    g.cellIdOfLocation('Z01-01-2').should.equal('0-0-1')
+    g.cellIdOfLocation('Z01-01-4').should.equal('0-0-3')
+  })
+
+  it('locationOf 와 cellIdOfLocation 가 bijective', () => {
+    const g = new MiniGrid({
+      cellOverrides: {
+        '0-0': { section: '01', unit: '01' },
+        '1-0': { section: '01', unit: '02' },
+        '2-0': { section: '01', unit: '03' }
+      }
+    })
+    for (let col = 0; col < 3; col++) {
+      for (let shelf = 0; shelf < 4; shelf++) {
+        const cellId = `${col}-0-${shelf}`
+        const loc = g.locationOf(cellId)
+        ;(loc !== null).should.be.true()
+        g.cellIdOfLocation(loc!).should.equal(cellId)
+      }
+    }
+  })
+
+  it('isEmpty cell 의 location 은 역인덱스에 없음', () => {
+    const g = new MiniGrid({
+      cellOverrides: {
+        '0-0': { section: '01', unit: '01' },
+        '1-0': { section: '01', unit: '02', isEmpty: true }
+      }
+    })
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+    ;(g.cellIdOfLocation('Z01-02-1') === null).should.be.true()
+  })
+
+  it('locPattern 변경 → 역인덱스 자동 재구축', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+    g.setState({ locPattern: '{s}/{u}/{sh}' })
+    ;(g.cellIdOfLocation('Z01-01-1') === null).should.be.true()
+    g.cellIdOfLocation('01/01/1').should.equal('0-0-0')
+  })
+})
+
+// ── Group 4: setCellOverride / clearCellOverride ───────────────────────────
+
+describe('RackGrid: setCellOverride / clearCellOverride', () => {
+  it('빈 cellOverrides 에 section/unit 추가', () => {
+    const g = new MiniGrid()
+    g.setCellOverride('0-0', { section: '01', unit: '01' })
+    g.cellOverrides['0-0'].should.deepEqual({ section: '01', unit: '01' })
+    g.locationOf('0-0-0').should.equal('Z01-01-1')
+  })
+
+  it('기존 override 에 partial 머지', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.setCellOverride('0-0', { isEmpty: true })
+    g.cellOverrides['0-0'].should.deepEqual({ section: '01', unit: '01', isEmpty: true })
+  })
+
+  it('partial 의 undefined 필드는 *해당 키 삭제*', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01', isEmpty: true } }
+    })
+    g.setCellOverride('0-0', { isEmpty: undefined })
+    g.cellOverrides['0-0'].should.deepEqual({ section: '01', unit: '01' })
+  })
+
+  it('모든 필드 삭제 시 override 자체 제거 (sparse 유지)', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { isEmpty: true } }
+    })
+    g.setCellOverride('0-0', { isEmpty: undefined })
+    Object.keys(g.cellOverrides).length.should.equal(0)
+  })
+
+  it('clearCellOverride — 한 위치 전체 제거', () => {
+    const g = new MiniGrid({
+      cellOverrides: {
+        '0-0': { section: '01', unit: '01' },
+        '1-0': { section: '01', unit: '02' }
+      }
+    })
+    g.clearCellOverride('0-0')
+    ;('0-0' in g.cellOverrides).should.be.false()
+    g.cellOverrides['1-0'].should.deepEqual({ section: '01', unit: '02' })
+  })
+
+  it('clearCellOverride → location 역인덱스 무효화', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+    g.clearCellOverride('0-0')
+    ;(g.cellIdOfLocation('Z01-01-1') === null).should.be.true()
+  })
+})
+
+// ── Group 5: setIsEmpty ────────────────────────────────────────────────────
+
+describe('RackGrid: setIsEmpty', () => {
+  it('여러 위치 동시 토글', () => {
+    const g = new MiniGrid()
+    g.setIsEmpty(['1-0', '3-0'], true)
+    g.cellOverrides['1-0'].isEmpty!.should.be.true()
+    g.cellOverrides['3-0'].isEmpty!.should.be.true()
+  })
+
+  it('isEmpty=false + 다른 필드 없으면 override 삭제 (sparse 유지)', () => {
+    const g = new MiniGrid({ cellOverrides: { '0-0': { isEmpty: true } } })
+    g.setIsEmpty(['0-0'], false)
+    ;('0-0' in g.cellOverrides).should.be.false()
+  })
+
+  it('isEmpty=false + section 있으면 override 유지', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01', isEmpty: true } }
+    })
+    g.setIsEmpty(['0-0'], false)
+    g.cellOverrides['0-0'].should.deepEqual({ section: '01', unit: '01', isEmpty: false })
+  })
+
+  it('isEmpty=true → 해당 cell location null', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    })
+    g.locationOf('0-0-0').should.equal('Z01-01-1')
+    g.setIsEmpty(['0-0'], true)
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+  })
+})
+
+// ── Group 6: setBorder ─────────────────────────────────────────────────────
+
+describe('RackGrid: setBorder', () => {
+  it("where='all' 4면 모두 같은 style", () => {
+    const g = new MiniGrid()
+    const style = { strokeStyle: '#000', lineWidth: 1, lineDash: 'solid' }
+    g.setBorder(['0-0'], style, 'all')
+    g.cellOverrides['0-0'].border!.should.deepEqual({
+      top: style, left: style, bottom: style, right: style
+    })
+  })
+
+  it("where='top' 만 설정", () => {
+    const g = new MiniGrid()
+    const style = { strokeStyle: '#000', lineWidth: 1, lineDash: 'solid' }
+    g.setBorder(['0-0'], style, 'top')
+    g.cellOverrides['0-0'].border!.should.deepEqual({ top: style })
+  })
+
+  it('style=null → 해당 side 삭제', () => {
+    const g = new MiniGrid({
+      cellOverrides: {
+        '0-0': { border: { top: 'x', left: 'y', bottom: 'z', right: 'w' } }
+      }
+    })
+    g.setBorder(['0-0'], null, 'top')
+    g.cellOverrides['0-0'].border!.should.deepEqual({ left: 'y', bottom: 'z', right: 'w' })
+  })
+
+  it('border 다 삭제되면 border 필드 자체 제거', () => {
+    const g = new MiniGrid({
+      cellOverrides: { '0-0': { section: '01', unit: '01', border: { top: 'x' } } }
+    })
+    g.setBorder(['0-0'], null, 'top')
+    ;('border' in g.cellOverrides['0-0']).should.be.false()
+    g.cellOverrides['0-0'].section!.should.equal('01')
+  })
+})
+
+// ── Group 7: increaseLocation — cw / ccw / aisle / skipNumbering ───────────
+
+describe('RackGrid: increaseLocation', () => {
+  it("cw — 단일 row, 좌→우 순서로 unit 증가", () => {
+    const g = new MiniGrid({ columns: 4, rows: 1 })
+    g.increaseLocation([], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].should.deepEqual({ section: '01', unit: '01' })
+    g.cellOverrides['1-0'].should.deepEqual({ section: '01', unit: '02' })
+    g.cellOverrides['2-0'].should.deepEqual({ section: '01', unit: '03' })
+    g.cellOverrides['3-0'].should.deepEqual({ section: '01', unit: '04' })
+  })
+
+  it("cw — 2 row grid, boustrophedon: row 0 좌→우, row 1 우→좌", () => {
+    const g = new MiniGrid({ columns: 3, rows: 2 })
+    g.increaseLocation([], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].unit!.should.equal('01')
+    g.cellOverrides['1-0'].unit!.should.equal('02')
+    g.cellOverrides['2-0'].unit!.should.equal('03')
+    g.cellOverrides['2-1'].unit!.should.equal('01')
+    g.cellOverrides['1-1'].unit!.should.equal('02')
+    g.cellOverrides['0-1'].unit!.should.equal('03')
+  })
+
+  it("ccw — 반대 방향", () => {
+    const g = new MiniGrid({ columns: 3, rows: 1 })
+    g.increaseLocation([], 'ccw', false, 1, 1)
+    g.cellOverrides['2-0'].unit!.should.equal('01')
+    g.cellOverrides['1-0'].unit!.should.equal('02')
+    g.cellOverrides['0-0'].unit!.should.equal('03')
+  })
+
+  it("aisle row 가 section 경계 — section 번호 +1", () => {
+    const g = new MiniGrid({
+      columns: 3, rows: 3,
+      cellOverrides: {
+        '0-1': { isEmpty: true },
+        '1-1': { isEmpty: true },
+        '2-1': { isEmpty: true }
+      }
+    })
+    g.increaseLocation([], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].section!.should.equal('01')
+    g.cellOverrides['0-0'].unit!.should.equal('01')
+    g.cellOverrides['0-2'].section!.should.equal('02')
+  })
+
+  it("skipNumbering=true 면 isEmpty cell 의 unit 건너뜀", () => {
+    const g = new MiniGrid({
+      columns: 4, rows: 1,
+      cellOverrides: { '2-0': { isEmpty: true } }
+    })
+    g.increaseLocation([], 'cw', true, 1, 1)
+    g.cellOverrides['0-0'].unit!.should.equal('01')
+    g.cellOverrides['1-0'].unit!.should.equal('02')
+    ;('section' in (g.cellOverrides['2-0'] || {})).should.be.false()
+    g.cellOverrides['3-0'].unit!.should.equal('03')
+  })
+
+  it("skipNumbering=false 면 isEmpty 도 번호 증가시킴", () => {
+    const g = new MiniGrid({
+      columns: 4, rows: 1,
+      cellOverrides: { '2-0': { isEmpty: true } }
+    })
+    g.increaseLocation([], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].unit!.should.equal('01')
+    g.cellOverrides['1-0'].unit!.should.equal('02')
+    g.cellOverrides['3-0'].unit!.should.equal('04')
+  })
+
+  it("padding 정확 — sectionDigits=3 → '001'", () => {
+    const g = new MiniGrid({ columns: 2, rows: 1, sectionDigits: 3, unitDigits: 3 })
+    g.increaseLocation([], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].section!.should.equal('001')
+    g.cellOverrides['0-0'].unit!.should.equal('001')
+  })
+
+  it("startSection / startUnit 적용", () => {
+    const g = new MiniGrid({ columns: 2, rows: 1 })
+    g.increaseLocation([], 'cw', false, 5, 10)
+    g.cellOverrides['0-0'].section!.should.equal('05')
+    g.cellOverrides['0-0'].unit!.should.equal('10')
+  })
+
+  it("posKeys 명시 시 그 cell 만 채번", () => {
+    const g = new MiniGrid({ columns: 4, rows: 1 })
+    g.increaseLocation(['0-0', '2-0'], 'cw', false, 1, 1)
+    g.cellOverrides['0-0'].unit!.should.equal('01')
+    g.cellOverrides['2-0'].unit!.should.equal('02')
+    ;('1-0' in g.cellOverrides).should.be.false()
+    ;('3-0' in g.cellOverrides).should.be.false()
+  })
+})