114 lines
4.4 KiB
TypeScript
114 lines
4.4 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
generateInitialCondition,
|
|
getInitialConditionRuntime,
|
|
listInitialConditionRuntimes,
|
|
registerInitialConditionRuntime
|
|
} from '../admin/src/caInitialConditionGenerators.js'
|
|
|
|
describe('CA initial condition runtimes', () => {
|
|
it('registers the built-in random soup generator', () => {
|
|
expect(listInitialConditionRuntimes().map((runtime) => runtime.id)).toEqual(
|
|
expect.arrayContaining(['random-soup', 'naga-markov'])
|
|
)
|
|
expect(getInitialConditionRuntime('random-soup')?.label).toBe('Random soup')
|
|
expect(getInitialConditionRuntime('naga-markov')?.label).toBe('Naga Markov chains')
|
|
})
|
|
|
|
it('generates deterministic cell coordinates for the same seed and density', () => {
|
|
const input = {
|
|
caClass: { dimensions: 2, states: 2 },
|
|
settings: { simulation: { grid: { size: [5, 5, 1] } } },
|
|
params: { density: 0.35, seed: 'repeatable' }
|
|
}
|
|
|
|
expect(generateInitialCondition('random-soup', input)).toEqual(generateInitialCondition('random-soup', input))
|
|
})
|
|
|
|
it('clamps density and records generator provenance in the persisted initial condition', () => {
|
|
const generated = generateInitialCondition('random-soup', {
|
|
caClass: { dimensions: 2, states: 2 },
|
|
settings: { simulation: { grid: { size: [3, 3, 1] } } },
|
|
params: { density: 2, seed: 'full' }
|
|
})
|
|
|
|
expect(generated.cells).toHaveLength(9)
|
|
expect(generated.generator).toEqual({ kind: 'random-soup', density: 1, seed: 'full' })
|
|
})
|
|
|
|
it('lets custom initial condition runtimes plug into the same contract', () => {
|
|
registerInitialConditionRuntime({
|
|
id: 'test-single-cell',
|
|
label: 'Test single cell',
|
|
generate: () => ({ type: 'cells', cells: [[1, 1, 0]], generator: { kind: 'test-single-cell' } })
|
|
})
|
|
|
|
expect(generateInitialCondition('test-single-cell', {
|
|
caClass: { dimensions: 2, states: 2 },
|
|
settings: {},
|
|
params: {}
|
|
}).cells).toEqual([[1, 1, 0]])
|
|
})
|
|
|
|
it('generates collision-free Naga Markov chains with directional continuity', () => {
|
|
const generated = generateInitialCondition('naga-markov', {
|
|
caClass: { dimensions: 3, states: 7 },
|
|
settings: { simulation: { grid: { size: [12, 12, 12] } } },
|
|
params: { count: 2, length: 5, sameTypeProbability: 1, seed: 'straight-nagas' }
|
|
})
|
|
|
|
expect(generated.cells).toHaveLength(10)
|
|
expect(new Set(generated.cells.map(([x, y, z]) => `${x}_${y}_${z}`)).size).toBe(10)
|
|
expect(generated.generator).toMatchObject({
|
|
kind: 'naga-markov',
|
|
count: 2,
|
|
length: 5,
|
|
sameTypeProbability: 1,
|
|
seed: 'straight-nagas',
|
|
created: 2
|
|
})
|
|
|
|
const occupied = new Set(generated.cells.map(([x, y, z]) => `${x}_${y}_${z}`))
|
|
for (let start = 0; start < generated.cells.length; start += 5) {
|
|
for (let index = start; index < start + 4; index += 1) {
|
|
const [x, y, z, arrow] = generated.cells[index]
|
|
const [nextX, nextY, nextZ, nextArrow] = generated.cells[index + 1]
|
|
expect(nextArrow).toBe(arrow)
|
|
if (arrow === 1) expect([nextX, nextY, nextZ]).toEqual([x + 1, y, z])
|
|
if (arrow === 2) expect([nextX, nextY, nextZ]).toEqual([x, y + 1, z])
|
|
if (arrow === 3) expect([nextX, nextY, nextZ]).toEqual([x, y, z + 1])
|
|
if (arrow === 4) expect([nextX, nextY, nextZ]).toEqual([x - 1, y, z])
|
|
if (arrow === 5) expect([nextX, nextY, nextZ]).toEqual([x, y - 1, z])
|
|
if (arrow === 6) expect([nextX, nextY, nextZ]).toEqual([x, y, z - 1])
|
|
}
|
|
const [x, y, z, arrow] = generated.cells[start + 4]
|
|
const terminalTarget =
|
|
arrow === 1 ? [x + 1, y, z] :
|
|
arrow === 2 ? [x, y + 1, z] :
|
|
arrow === 3 ? [x, y, z + 1] :
|
|
arrow === 4 ? [x - 1, y, z] :
|
|
arrow === 5 ? [x, y - 1, z] :
|
|
[x, y, z - 1]
|
|
expect(occupied.has(terminalTarget.join('_'))).toBe(false)
|
|
}
|
|
})
|
|
|
|
it('rejects duplicate runtime ids and missing implementations', () => {
|
|
expect(() =>
|
|
registerInitialConditionRuntime({
|
|
id: 'random-soup',
|
|
label: 'Duplicate random soup',
|
|
generate: () => ({ type: 'cells', cells: [], generator: { kind: 'random-soup' } })
|
|
})
|
|
).toThrow('already registered')
|
|
|
|
expect(() =>
|
|
generateInitialCondition('missing-generator', {
|
|
caClass: { dimensions: 2, states: 2 },
|
|
settings: {},
|
|
params: {}
|
|
})
|
|
).toThrow('unavailable')
|
|
})
|
|
})
|