356 lines
16 KiB
TypeScript
356 lines
16 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
||
import { bundleWires, cableFromPins, cableIntoPins, cablePanel, nameTags, pinGroups, plugInto, plugLayout, syncCables } from '../app/lib/logic/cables'
|
||
import { dropLinks, dropPins } from '../app/lib/logic/fit'
|
||
import { compile, rowSource } from '../app/lib/logic/compile'
|
||
import { chipPins, panelOffsets, pinPos, shapeOf } from '../app/lib/logic/geometry'
|
||
import { copySelection, createProject, lookup, pasteClip } from '../app/lib/logic/ops'
|
||
import { circuitRoutes } from '../app/lib/logic/routing'
|
||
import { Simulator } from '../app/lib/logic/sim'
|
||
import type { CircuitNode, ComponentDef, Project } from '../app/lib/logic/types'
|
||
|
||
/** Switches A0..A3 and B0..B3 wired to an Adder 4, its outputs to lamps. */
|
||
function adder(): { p: Project; def: ComponentDef; ins: string[]; outs: string[] } {
|
||
const p = createProject({ examples: true })
|
||
const pins = chipPins(lookup(p)('ex-add4')!)
|
||
const ins = pins.inputs.map(x => x.key)
|
||
const outs = pins.outputs.map(x => x.key)
|
||
const def: ComponentDef = {
|
||
id: 'root',
|
||
name: 'Root',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'add', kind: 'chip', chip: 'ex-add4', x: 20, y: 0 },
|
||
...pins.inputs.map((x, i) => ({ id: `s${i}`, kind: 'input' as const, x: 0, y: i * 3, label: x.label })),
|
||
...pins.outputs.map((_, i) => ({ id: `l${i}`, kind: 'lamp' as const, x: 50, y: 20 + i * 2 })),
|
||
],
|
||
wires: [
|
||
...ins.map((k, i) => ({ id: `wi${i}`, from: { node: `s${i}`, pin: 'q' }, to: { node: 'add', pin: k } })),
|
||
...outs.map((k, i) => ({ id: `wo${i}`, from: { node: 'add', pin: k }, to: { node: `l${i}`, pin: 'a' } })),
|
||
],
|
||
}
|
||
p.components.push(def)
|
||
return { p, def, ins, outs }
|
||
}
|
||
|
||
function sums(p: Project, def: ComponentDef): string[] {
|
||
const out: string[] = []
|
||
for (const [a, b] of [[3, 5], [15, 1], [9, 9], [0, 0]] as const) {
|
||
const s = new Simulator(compile(lookup(p), def.id))
|
||
for (let i = 0; i < 4; i++) {
|
||
s.setSource(`s${i}`, ((a >> i) & 1) === 1)
|
||
s.setSource(`s${i + 4}`, ((b >> i) & 1) === 1)
|
||
}
|
||
s.run()
|
||
out.push([0, 1, 2, 3, 4].map(i => s.pin(`l${i}`, 'a')).join(''))
|
||
}
|
||
return out
|
||
}
|
||
|
||
const node = (def: ComponentDef, id: string) => def.nodes.find(n => n.id === id)!
|
||
|
||
/** Where each wire on the single-wire side of a cable end meets the part it is plugged into. */
|
||
function touches(p: Project, def: ComponentDef, end: CircuitNode): boolean {
|
||
const get = lookup(p)
|
||
const wires = end.kind === 'bundle' ? def.wires.filter(w => w.to.node === end.id) : def.wires.filter(w => w.from.node === end.id)
|
||
return wires.every(w => {
|
||
const a = pinPos(node(def, w.from.node), shapeOf(node(def, w.from.node), get), w.from.pin, 'out')!
|
||
const b = pinPos(node(def, w.to.node), shapeOf(node(def, w.to.node), get), w.to.pin, 'in')!
|
||
return a.x === b.x && a.y === b.y
|
||
})
|
||
}
|
||
|
||
describe('plugged cable ends', () => {
|
||
it('bundling wires into one part plugs the split straight onto its pins', () => {
|
||
const { p, def } = adder()
|
||
const before = sums(p, def)
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
expect(res.split.plug).toBe('add')
|
||
expect(res.bundle.plug).toBeUndefined()
|
||
expect(touches(p, def, res.split)).toBe(true)
|
||
expect(res.split.x).toBe(19)
|
||
expect(sums(p, def)).toEqual(before)
|
||
// The plugged wires have no length, so there is nothing to draw.
|
||
const routes = circuitRoutes(def, new Map(def.nodes.map(n => [n.id, shapeOf(n, lookup(p))])))
|
||
const plugged = new Set(def.wires.filter(w => w.from.node === res.split.id).map(w => w.id))
|
||
for (const r of routes.filter(r => plugged.has(r.id))) expect(r.grid).toHaveLength(2)
|
||
})
|
||
|
||
it('a bundle plugs onto the outputs, and the free split names its wires after them', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wo0', 'wo1', 'wo2', 'wo3', 'wo4'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
expect(res.bundle.plug).toBe('add')
|
||
syncCables(p)
|
||
expect(res.split.names).toEqual(['S0', 'S1', 'S2', 'S3', 'Cout'])
|
||
// Names never change the shape: the pins stay where they were.
|
||
const s = shapeOf(res.split, lookup(p))
|
||
expect(s.body).toEqual({ x: 0, y: -0.5, w: 1, h: 5 })
|
||
expect(s.outputs.every(o => o.dx === 1)).toBe(true)
|
||
// Plugged in, the bundle leaves the names to the component.
|
||
expect(nameTags(def, res.bundle, lookup(p))).toEqual([])
|
||
})
|
||
|
||
it('a free end shows only the names the part at the other end does not show already', () => {
|
||
const { p, def } = adder()
|
||
const get = lookup(p)
|
||
const res = bundleWires(def, ['wo0', 'wo1', 'wo2', 'wo3', 'wo4'], get)
|
||
if (!res.ok) throw new Error(res.error)
|
||
syncCables(p)
|
||
// Lamps without a name show the wire's name, dimmed.
|
||
expect(nameTags(def, res.split, get)).toEqual(['', '', '', '', ''])
|
||
// A lamp with another name, and a NAND gate, don't.
|
||
node(def, 'l1').label = 'Bit 1'
|
||
def.nodes.push({ id: 'g', kind: 'nand', x: 60, y: 30 })
|
||
def.wires.find(w => w.from.node === res.split.id && w.from.pin === 'b4')!.to = { node: 'g', pin: 'a' }
|
||
expect(nameTags(def, res.split, get)).toEqual(['', 'S1', '', '', 'Cout'])
|
||
})
|
||
|
||
it('a bundle fed by switches of the same names shows none', () => {
|
||
const { p, def } = adder()
|
||
const get = lookup(p)
|
||
const ins = chipPins(get('ex-add4')!).inputs
|
||
def.nodes.push({ id: 'b', kind: 'bundle', bits: 4, x: 8, y: 2 })
|
||
def.wires = def.wires.filter(w => !['wi4', 'wi5', 'wi6', 'wi7'].includes(w.id))
|
||
for (const i of [0, 1, 2, 3]) def.wires.push({ id: `f${i}`, from: { node: `s${i + 4}`, pin: 'q' }, to: { node: 'b', pin: `b${i}` } })
|
||
syncCables(p)
|
||
expect(node(def, 'b').names).toEqual(ins.slice(4, 8).map(x => x.label))
|
||
expect(nameTags(def, node(def, 'b'), get)).toEqual(['', '', '', ''])
|
||
})
|
||
|
||
it('names come from what drives the wires, else from what they drive', () => {
|
||
const { p, def } = adder()
|
||
for (const i of [0, 1, 2, 3]) delete node(def, `s${i}`).label
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
syncCables(p)
|
||
expect(res.bundle.names).toEqual(['A0', 'A1', 'A2', 'A3'])
|
||
node(def, 's1').label = 'X'
|
||
syncCables(p)
|
||
expect(res.bundle.names).toEqual(['A0', 'X', 'A2', 'A3'])
|
||
})
|
||
|
||
it('follows its part, and comes loose when the pins no longer line up', () => {
|
||
const { p, def, ins } = adder()
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
const chip = node(def, 'add')
|
||
chip.x += 7
|
||
chip.y += 3
|
||
syncCables(p)
|
||
expect(touches(p, def, res.split)).toBe(true)
|
||
// Rewire one wire to a pin further down: no longer in the cable's order on one edge.
|
||
def.wires.find(w => w.from.node === res.split.id && w.from.pin === 'b0')!.to.pin = ins[8]!
|
||
syncCables(p)
|
||
expect(res.split.plug).toBeUndefined()
|
||
})
|
||
|
||
it('a free end dropped with its pins on a part plugs in', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wo0', 'wo1', 'wo2', 'wo3', 'wo4'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
const { x, y } = res.bundle
|
||
delete res.bundle.plug
|
||
res.bundle.x += 3
|
||
syncCables(p)
|
||
expect(res.bundle.plug).toBeUndefined()
|
||
res.bundle.x = x
|
||
res.bundle.y = y
|
||
syncCables(p)
|
||
expect(res.bundle.plug).toBe('add')
|
||
})
|
||
|
||
it('one wire landing on a part does not plug the whole end in', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wo0', 'wo1', 'wo2', 'wo3', 'wo4'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
// Only the last wire runs on, to a lamp sitting right on its pin.
|
||
def.wires = def.wires.filter(w => w.from.node !== res.split.id || w.from.pin === 'b4')
|
||
const lamp = node(def, 'l4')
|
||
const pin = shapeOf(res.split, lookup(p)).outputs[4]!
|
||
lamp.x = res.split.x + pin.dx
|
||
lamp.y = res.split.y + pin.dy
|
||
syncCables(p)
|
||
expect(touches(p, def, res.split)).toBe(true)
|
||
expect(res.split.plug).toBeUndefined()
|
||
})
|
||
|
||
it('takes the spacing of pins further apart', () => {
|
||
const p = createProject({ examples: true })
|
||
const get = lookup(p)
|
||
const def: ComponentDef = {
|
||
id: 'root',
|
||
name: 'Root',
|
||
symbol: 'box',
|
||
nodes: [
|
||
{ id: 'g', kind: 'nand', x: 10, y: 0 },
|
||
{ id: 'b', kind: 'split', bits: 2, x: 0, y: 0 },
|
||
],
|
||
wires: [
|
||
{ id: 'w0', from: { node: 'b', pin: 'b0' }, to: { node: 'g', pin: 'a' } },
|
||
{ id: 'w1', from: { node: 'b', pin: 'b1' }, to: { node: 'g', pin: 'b' } },
|
||
],
|
||
}
|
||
p.components.push(def)
|
||
const split = node(def, 'b')
|
||
expect(plugInto(def, split, 'g', get)).toBe(true)
|
||
const gate = shapeOf(node(def, 'g'), get).inputs
|
||
expect(split.pitch).toBe(gate[1]!.dy - gate[0]!.dy)
|
||
expect(touches(p, def, split)).toBe(true)
|
||
})
|
||
})
|
||
|
||
describe('input panels for cables', () => {
|
||
it('a bundle gets a panel with a switch per wire, plugged in and named', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
// Take the switches away: the bundle has nothing driving it.
|
||
def.nodes = def.nodes.filter(n => !['s0', 's1', 's2', 's3'].includes(n.id))
|
||
def.wires = def.wires.filter(w => !['s0', 's1', 's2', 's3'].includes(w.from.node))
|
||
syncCables(p)
|
||
const panel = cablePanel(def, res.bundle.id, lookup(p))!
|
||
syncCables(p)
|
||
expect(panel.rows!.map(r => r.name)).toEqual(['A0', 'A1', 'A2', 'A3'])
|
||
expect(res.bundle.plug).toBe(panel.id)
|
||
expect(touches(p, def, res.bundle)).toBe(true)
|
||
// Flipping row 2 sets A2.
|
||
const s = new Simulator(compile(lookup(p), def.id))
|
||
s.setSource(rowSource(panel.id, panel.rows![2]!.id), true)
|
||
s.run()
|
||
expect([0, 1, 2, 3].map(i => s.pin(`l${i}`, 'a')).join('')).toBe('0010')
|
||
})
|
||
|
||
it('a bundle plugged into a panel takes the spacing of its rows', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
def.nodes = def.nodes.filter(n => !['s0', 's1', 's2', 's3'].includes(n.id))
|
||
def.wires = def.wires.filter(w => !['s0', 's1', 's2', 's3'].includes(w.from.node))
|
||
const panel = cablePanel(def, res.bundle.id, lookup(p))!
|
||
// A gap of two rows above the third row.
|
||
const at = panelOffsets(panel.rows!)
|
||
panel.rows!.forEach((r, i) => (r.dy = at[i]! + (i >= 2 ? 2 : 0)))
|
||
syncCables(p)
|
||
expect(res.bundle.offsets).toEqual([0, 1, 4, 5])
|
||
expect(touches(p, def, res.bundle)).toBe(true)
|
||
})
|
||
})
|
||
|
||
describe('copying plugged ends', () => {
|
||
it('a copied end plugs into the copy of its part, or into nothing', () => {
|
||
const { p, def } = adder()
|
||
const res = bundleWires(def, ['wi0', 'wi1', 'wi2', 'wi3'], lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
const both = pasteClip(def, copySelection(def, new Set(['add', res.split.id])), 0, 30)
|
||
const copy = both.map(id => node(def, id)).find(n => n.kind === 'split')!
|
||
const chip = both.map(id => node(def, id)).find(n => n.kind === 'chip')!
|
||
expect(copy.plug).toBe(chip.id)
|
||
const alone = pasteClip(def, copySelection(def, new Set([res.split.id])), 0, 60)
|
||
expect(node(def, alone[0]!).plug).toBeUndefined()
|
||
})
|
||
})
|
||
|
||
describe('cables saved before plugs existed', () => {
|
||
it('stay where they are and compute the same; only names are added', () => {
|
||
const { p, def } = adder()
|
||
const before = sums(p, def)
|
||
def.nodes.push({ id: 'b', kind: 'bundle', bits: 4, x: 8, y: 2 }, { id: 'sp', kind: 'split', bits: 4, x: 16, y: 2 })
|
||
def.wires = def.wires.filter(w => !['wi0', 'wi1', 'wi2', 'wi3'].includes(w.id))
|
||
const ins = chipPins(lookup(p)('ex-add4')!).inputs
|
||
for (const i of [0, 1, 2, 3]) {
|
||
def.wires.push({ id: `f${i}`, from: { node: `s${i}`, pin: 'q' }, to: { node: 'b', pin: `b${i}` } })
|
||
def.wires.push({ id: `t${i}`, from: { node: 'sp', pin: `b${i}` }, to: { node: 'add', pin: ins[i]!.key } })
|
||
}
|
||
def.wires.push({ id: 'c', from: { node: 'b', pin: 'q' }, to: { node: 'sp', pin: 'a' } })
|
||
syncCables(p)
|
||
expect([node(def, 'b').x, node(def, 'b').y, node(def, 'sp').x, node(def, 'sp').y]).toEqual([8, 2, 16, 2])
|
||
expect(node(def, 'b').plug ?? node(def, 'sp').plug).toBeUndefined()
|
||
expect(node(def, 'sp').names).toEqual(['A0', 'A1', 'A2', 'A3'])
|
||
expect(sums(p, def)).toEqual(before)
|
||
})
|
||
})
|
||
|
||
describe('plugging in more often', () => {
|
||
it('outputs of one part bundled to scattered targets: the bundle plugs into the part', () => {
|
||
const { p, def, outs } = adder()
|
||
// Lamps in reverse order: wire order follows the Adder's pins, not the lamps.
|
||
for (const i of [0, 1, 2, 3, 4]) node(def, `l${i}`).y = 40 - i * 3
|
||
const res = bundleWires(def, outs.map((_, i) => `wo${i}`), lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
expect(res.bundle.plug).toBe('add')
|
||
expect(touches(p, def, res.bundle)).toBe(true)
|
||
})
|
||
|
||
it('an end with only some of its wires on a part still plugs in', () => {
|
||
const { p, def, ins } = adder()
|
||
def.nodes.push({ id: 'sp', kind: 'split', bits: 5, x: 0, y: 30 })
|
||
for (const i of [0, 1, 2, 3]) def.wires.push({ id: `t${i}`, from: { node: 'sp', pin: `b${i}` }, to: { node: 'add', pin: ins[i]! } })
|
||
const sp = node(def, 'sp')
|
||
const lay = plugLayout(def, sp, node(def, 'add'), lookup(p))!
|
||
sp.x = lay.x
|
||
sp.y = lay.y
|
||
syncCables(p)
|
||
expect(sp.plug).toBe('add')
|
||
})
|
||
})
|
||
|
||
describe('a cable straight off a part', () => {
|
||
it('offers numbered groups of pins and all of them', () => {
|
||
const groups = pinGroups(['A0', 'A1', 'A2', 'A3', 'B0', 'B1', 'B2', 'B3', 'Cin'].map(l => ({ key: l, label: l })))
|
||
expect(groups.map(g => g.label)).toEqual(['A0–A3', 'B0–B3', 'all 9'])
|
||
const outs = pinGroups(['S0', 'S1', 'S2', 'S3', 'Cout'].map(l => ({ key: l, label: l })), k => k !== 'S2')
|
||
expect(outs.map(g => g.label)).toEqual(['S0–S1', 'all 4 (S0–Cout)'])
|
||
})
|
||
|
||
it('from outputs: a bundle plugged on the pins, a free split with their names, then dropped onto the next part', () => {
|
||
const { p, def, outs } = adder()
|
||
const get = lookup(p)
|
||
// Take the lamps away: the outputs are free.
|
||
def.wires = def.wires.filter(w => w.from.node !== 'add')
|
||
const res = cableFromPins(def, 'add', outs.slice(0, 4), get)
|
||
if (!res.ok) throw new Error(res.error)
|
||
expect(res.bundle.plug).toBe('add')
|
||
expect(touches(p, def, res.bundle)).toBe(true)
|
||
syncCables(p)
|
||
expect(res.split.names).toEqual(['S0', 'S1', 'S2', 'S3'])
|
||
expect(res.split.x).toBeGreaterThan(res.bundle.x)
|
||
// A second adder: drop the split right onto its A inputs.
|
||
def.nodes.push({ id: 'add2', kind: 'chip', chip: 'ex-add4', x: 60, y: 0 })
|
||
const lay = (() => {
|
||
const s = shapeOf(node(def, 'add2'), get).inputs[0]!
|
||
return { x: 60 + s.dx - 1, y: s.dy }
|
||
})()
|
||
res.split.x = lay.x
|
||
res.split.y = lay.y
|
||
const moved = dropPins(def, [res.split], n => shapeOf(n, get))
|
||
const still = dropPins(def, def.nodes.filter(n => n !== res.split), n => shapeOf(n, get))
|
||
const drop = dropLinks(moved, still, 0)!
|
||
expect(drop.links).toHaveLength(4)
|
||
def.wires.push(...drop.links.map((l, i) => ({ id: `d${i}`, ...l })))
|
||
syncCables(p)
|
||
expect(res.split.plug).toBe('add2')
|
||
// A0 of the first adder set: S0 = 1 arrives at A0 of the second, whose S0 shows it.
|
||
def.nodes.push({ id: 'out', kind: 'lamp', x: 80, y: 0 })
|
||
def.wires.push({ id: 'o', from: { node: 'add2', pin: outs[0]! }, to: { node: 'out', pin: 'a' } })
|
||
const s = new Simulator(compile(get, def.id))
|
||
s.setSource('s0', true)
|
||
s.run()
|
||
expect(s.pin('out', 'a')).toBe(1)
|
||
})
|
||
|
||
it('into inputs: a split plugged on the free pins, a free bundle behind it', () => {
|
||
const { p, def, ins } = adder()
|
||
def.wires = def.wires.filter(w => w.to.node !== 'add')
|
||
const res = cableIntoPins(def, 'add', ins.slice(4, 8), lookup(p))
|
||
if (!res.ok) throw new Error(res.error)
|
||
expect(res.split.plug).toBe('add')
|
||
expect(touches(p, def, res.split)).toBe(true)
|
||
expect(res.bundle.x).toBeLessThan(res.split.x)
|
||
syncCables(p)
|
||
expect(res.bundle.names).toEqual(['B0', 'B1', 'B2', 'B3'])
|
||
// Those inputs are taken now: no second cable into them.
|
||
expect(cableIntoPins(def, 'add', ins.slice(4, 8), lookup(p)).ok).toBe(false)
|
||
})
|
||
})
|