logigate/tests/ports.test.ts

366 lines
18 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { describe, expect, it } from 'vitest'
import { cableFromPins, cableIntoPins } from '../app/lib/logic/cables'
import { checkCircuit, doublyFedLines } from '../app/lib/logic/check'
import { compile } from '../app/lib/logic/compile'
import { pinKindOf, shapeOf } from '../app/lib/logic/geometry'
import { pinName } from '../app/lib/logic/labels'
import { createProject, lineForWire, lookup, pruneWires, splitPort, unpackChip } from '../app/lib/logic/ops'
import { attachPanel, syncPanels } from '../app/lib/logic/panels'
import { toProject } from '../app/lib/logic/project'
import { Simulator } from '../app/lib/logic/sim'
import type { CircuitNode, ComponentDef, Project, Wire } from '../app/lib/logic/types'
const w = (id: string, from: [string, string], to: [string, string]): Wire => ({ id, from: { node: from[0], pin: from[1] }, to: { node: to[0], pin: to[1] } })
/**
* The "Mini HDMI" of the connector tests: D0 and D1 out → in, HPD back.
* Source sends A and B out of its out port and reports HPD; Sink shows the
* data as X and Y and drives HPD from H. Root places one of each, unwired.
*/
function project(): Project {
const p = createProject({ examples: false })
p.connectors = [{ id: 'hdmi', name: 'Mini HDMI', color: 'blue', lines: [{ name: 'D0' }, { name: 'D1' }, { name: 'HPD', back: true }] }]
const source: ComponentDef = {
id: 'source',
name: 'Source',
symbol: 'box',
nodes: [
{ id: 'a', kind: 'input', x: 0, y: 0, label: 'A' },
{ id: 'b', kind: 'input', x: 0, y: 2, label: 'B' },
{ id: 'tx', kind: 'portout', conn: 'hdmi', x: 20, y: 0, label: 'OUT' },
{ id: 'hpd', kind: 'output', x: 10, y: 8, label: 'HPD' },
],
wires: [w('w1', ['a', 'q'], ['tx', 'l0']), w('w2', ['b', 'q'], ['tx', 'l1']), w('w3', ['tx', 'l2'], ['hpd', 'a'])],
}
const sink: ComponentDef = {
id: 'sink',
name: 'Sink',
symbol: 'box',
nodes: [
{ id: 'rx', kind: 'portin', conn: 'hdmi', x: 0, y: 0, label: 'IN' },
{ id: 'x', kind: 'output', x: 20, y: 0, label: 'X' },
{ id: 'y', kind: 'output', x: 20, y: 2, label: 'Y' },
{ id: 'h', kind: 'input', x: 10, y: 8, label: 'H' },
],
wires: [w('w1', ['rx', 'l0'], ['x', 'a']), w('w2', ['rx', 'l1'], ['y', 'a']), w('w3', ['h', 'q'], ['rx', 'l2'])],
}
const root: ComponentDef = {
id: 'root',
name: 'Root',
symbol: 'box',
nodes: [
{ id: 'sa', kind: 'input', x: 0, y: 0 },
{ id: 'sb', kind: 'input', x: 0, y: 2 },
{ id: 'sh', kind: 'input', x: 0, y: 8 },
{ id: 'src', kind: 'chip', chip: 'source', x: 6, y: 0 },
{ id: 'snk', kind: 'chip', chip: 'sink', x: 30, y: 0 },
{ id: 'lamp', kind: 'lamp', x: 50, y: 0 },
],
wires: [w('r1', ['sa', 'q'], ['src', 'a']), w('r2', ['sb', 'q'], ['src', 'b']), w('r3', ['sh', 'q'], ['snk', 'h'])],
}
p.components.push(source, sink, root)
return p
}
const node = (p: Project, def: string, id: string) => p.components.find(d => d.id === def)!.nodes.find(n => n.id === id)!
const root = (p: Project) => p.components.find(d => d.id === 'root')!
function run(p: Project, on: Record<string, boolean>) {
const s = new Simulator(compile(lookup(p), 'root'))
for (const [k, v] of Object.entries(on)) s.setSource(k, v)
s.run()
return s
}
describe('ports on a component box', () => {
it('sit at the very top of their side, above the single pins', () => {
const p = project()
// More single pins than before, so a port at the bottom would show.
node(p, 'sink', 'h').y = -4
p.components.find(d => d.id === 'sink')!.nodes.push({ id: 'k', kind: 'input', x: 10, y: 10, label: 'K' })
const get = lookup(p)
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0 }, get)
expect(snk.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['h', 1], ['k', 2]])
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0 }, get)
expect(src.outputs.map(o => [o.key, o.dx, o.dy])).toEqual([['tx', src.body.w, 0], ['hpd', src.body.w, 1]])
})
it('also at the top of a box drawn by hand', () => {
const p = project()
const sink = p.components.find(d => d.id === 'sink')!
sink.design = { w: 6, h: 3, pinAt: { h: 0, x: 2 } }
const s = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0 }, lookup(p))
expect(s.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['h', 1]])
expect(s.outputs.map(o => [o.key, o.dx, o.dy])).toEqual([['x', 6, 2], ['y', 6, 3]])
})
it('split, a port shows a pin per line right below its socket, each facing out of its side', () => {
const p = project()
const get = lookup(p)
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, get)
// In port on the left: D0 and D1 come in (inputs), HPD goes back out (an output on the left).
expect(snk.inputs.map(i => [i.key, i.label, i.dx, i.dy, i.face])).toEqual([
['rx', 'IN', 0, 0, undefined],
['rx.l0', 'D0', 0, 1, -1],
['rx.l1', 'D1', 0, 2, -1],
['h', 'H', 0, 4, undefined],
])
expect(snk.outputs.find(o => o.key === 'rx.l2')).toMatchObject({ label: 'HPD', dx: 0, dy: 3, face: -1, port: 'rx' })
// Out port on the right: D0 and D1 go out, HPD comes back in (an input on the right).
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts: ['tx'] }, get)
const right = src.body.w
expect(src.outputs.map(o => [o.key, o.dx, o.dy, o.face])).toEqual([
['tx', right, 0, undefined],
['tx.l0', right, 1, 1],
['tx.l1', right, 2, 1],
['hpd', right, 4, undefined],
])
expect(src.inputs.find(i => i.key === 'tx.l2')).toMatchObject({ label: 'HPD', dx: right, dy: 3, face: 1 })
// Lines take single wires; the socket still takes the cable.
expect(pinKindOf(snk.inputs[1]!)).toBe('')
expect(pinKindOf(snk.inputs[0]!)).toBe('c:hdmi')
})
it('split on a box drawn by hand, the lines follow the socket and push the pins below down', () => {
const p = project()
p.components.find(d => d.id === 'sink')!.design = { w: 6, h: 3, pinAt: { h: 1 } }
const s = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, lookup(p))
expect(s.inputs.map(i => [i.key, i.dy])).toEqual([['rx', 0], ['rx.l0', 1], ['rx.l1', 2], ['h', 4]])
expect(s.outputs.find(o => o.key === 'rx.l2')).toMatchObject({ dx: 0, dy: 3 })
})
it('a line wired from outside drives the inside, and a back line brings the inside out', () => {
const p = project()
node(p, 'root', 'snk').splitPorts = ['rx']
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
for (const [a, h] of [[0, 0], [1, 0], [0, 1], [1, 1]] as const) {
const s = run(p, { sa: !!a, sh: !!h })
expect([s.pin('snk', 'x'), s.pin('snk', 'rx.l2'), s.pin('lamp', 'q')]).toEqual([a, h, h])
}
})
it('an out port split the same way: its lines leave on the right, the back line comes in there', () => {
const p = project()
node(p, 'root', 'src').splitPorts = ['tx']
root(p).wires.push(w('d1', ['src', 'tx.l1'], ['lamp', 'a']), w('hp', ['sh', 'q'], ['src', 'tx.l2']))
for (const [b, h] of [[0, 1], [1, 0], [1, 1]] as const) {
const s = run(p, { sb: !!b, sh: !!h })
expect([s.pin('lamp', 'q'), s.pin('src', 'hpd')]).toEqual([b, h])
}
})
it('a cable on the socket and wires on the lines work together', () => {
const p = project()
node(p, 'root', 'snk').splitPorts = ['rx']
root(p).wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
const s = run(p, { sa: true, sb: false, sh: true })
// The cable still carries every line; the line pins show what it carries.
expect([s.pin('snk', 'x'), s.pin('snk', 'y'), s.pin('src', 'hpd')]).toEqual([1, 0, 1])
expect([s.pin('snk', 'rx.l0'), s.pin('snk', 'rx.l1'), s.pin('lamp', 'q')]).toEqual([1, 0, 1])
expect(doublyFedLines(root(p), node(p, 'root', 'snk'), lookup(p))).toEqual([])
// A wire into a line the cable feeds as well: both drive it, and the check says so.
root(p).wires.push(w('d0', ['sb', 'q'], ['snk', 'rx.l0']))
expect(doublyFedLines(root(p), node(p, 'root', 'snk'), lookup(p))).toEqual(['rx.l0'])
expect(checkCircuit(root(p), lookup(p)).some(i => i.level === 'error' && i.text.includes('D0'))).toBe(true)
})
it('passes split lines through a component that offers an inner part’s port as its own', () => {
const p = project()
p.components.push({
id: 'box',
name: 'Box',
symbol: 'box',
nodes: [
{ id: 'i', kind: 'input', x: 0, y: 0, label: 'I' },
{ id: 'inner', kind: 'chip', chip: 'source', x: 6, y: 0 },
{ id: 'p2', kind: 'portout', conn: 'hdmi', x: 30, y: 0 },
],
wires: [w('b1', ['i', 'q'], ['inner', 'a']), w('b2', ['inner', 'tx'], ['p2', 'bus'])],
})
root(p).nodes.push({ id: 'bx', kind: 'chip', chip: 'box', x: 6, y: 20, splitPorts: ['p2'] })
root(p).wires.push(w('r9', ['sa', 'q'], ['bx', 'i']), w('l0', ['bx', 'p2.l0'], ['lamp', 'a']))
expect(run(p, { sa: true }).pin('lamp', 'q')).toBe(1)
expect(run(p, { sa: false }).pin('lamp', 'q')).toBe(0)
})
it('joining a port again removes the wires on its lines and keeps the cable', () => {
const p = project()
const r = root(p)
expect(splitPort(p, r, 'snk', 'rx', true)).toBe(0)
expect(node(p, 'root', 'snk').splitPorts).toEqual(['rx'])
r.wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']), w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
expect(pruneWires(p)).toBe(false)
expect(splitPort(p, r, 'snk', 'rx', false)).toBe(2)
expect(node(p, 'root', 'snk').splitPorts).toBeUndefined()
expect(r.wires.map(x => x.id)).toEqual(['r1', 'r2', 'r3', 'cable'])
// No port of that name: nothing changes.
expect(splitPort(p, r, 'snk', 'nope', true)).toBe(0)
expect(node(p, 'root', 'snk').splitPorts).toBeUndefined()
})
it('a single wire dropped on a socket takes the first free line that runs its way', () => {
const p = project()
const r = root(p)
// Into the sink's in port: D0, then D1; from it: HPD.
expect(lineForWire(p, r, 'snk', 'rx', true)).toBe('rx.l0')
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
r.wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
expect(lineForWire(p, r, 'snk', 'rx', true)).toBe('rx.l1')
r.wires.push(w('d1', ['sb', 'q'], ['snk', 'rx.l1']))
expect(lineForWire(p, r, 'snk', 'rx', true)).toBeNull()
// A line coming out can feed another wire.
r.wires.push(w('hp', ['snk', 'rx.l2'], ['lamp', 'a']))
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
// The source's out port: its back line goes in, D0 comes out first.
expect(lineForWire(p, r, 'src', 'tx', true)).toBe('tx.l2')
expect(lineForWire(p, r, 'src', 'tx', false)).toBe('tx.l0')
expect(lineForWire(p, r, 'src', 'nope', true)).toBeNull()
})
it('cleans up wires on lines whose port is no longer split', () => {
const p = project()
node(p, 'root', 'snk').splitPorts = ['rx']
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
expect(pruneWires(p)).toBe(false)
delete node(p, 'root', 'snk').splitPorts
expect(pruneWires(p)).toBe(true)
expect(root(p).wires.some(x => x.id === 'd0')).toBe(false)
})
it('a typed cable never plugs into a line, a single wire never into a socket', () => {
const p = project()
node(p, 'root', 'snk').splitPorts = ['rx']
root(p).wires.push(w('bad1', ['src', 'tx'], ['snk', 'rx.l0']), w('bad2', ['sa', 'q'], ['snk', 'rx']))
expect(pruneWires(p)).toBe(true)
expect(root(p).wires.map(x => x.id)).toEqual(['r1', 'r2', 'r3'])
})
it('names a line pin after its line, keeps the setting through loading and leaves line pins off docked panels', () => {
const p = project()
const snk = node(p, 'root', 'snk')
snk.splitPorts = ['rx']
expect(pinName(snk, 'rx.l1', lookup(p))).toBe('D1')
const data = JSON.parse(JSON.stringify(p))
data.components.find((d: ComponentDef) => d.id === 'root').nodes.find((n: CircuitNode) => n.id === 'src').splitPorts = 'tx'
const back = toProject(data)
expect(node(back, 'root', 'snk').splitPorts).toEqual(['rx'])
expect(node(back, 'root', 'src').splitPorts).toBeUndefined()
// A docked input panel gets a switch for H only: the socket and the lines are the cable's.
root(p).wires = root(p).wires.filter(x => x.id !== 'r3')
const panel = attachPanel(p, root(p), 'snk')!
expect(panel.rows!.map(r => r.id)).toEqual(['h'])
})
it('with a cable in the socket, a dropped wire takes no line going in: the cable feeds those', () => {
const p = project()
const r = root(p)
r.wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']))
// Into the sink's in port: D0 and D1 come through the cable. HPD can still be read.
expect(lineForWire(p, r, 'snk', 'rx', true)).toBeNull()
expect(lineForWire(p, r, 'snk', 'rx', false)).toBe('rx.l2')
// The source's out port: HPD comes back through the cable, D0 can still be read.
expect(lineForWire(p, r, 'src', 'tx', true)).toBeNull()
expect(lineForWire(p, r, 'src', 'tx', false)).toBe('tx.l0')
})
it('a line going in with neither a wire nor a cable is an open input', () => {
const p = project()
node(p, 'root', 'snk').splitPorts = ['rx']
root(p).wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']))
expect(checkCircuit(root(p), lookup(p)).some(i => i.level === 'warn' && i.text === 'Sink: D1 not connected (reads 0)')).toBe(true)
// A cable in the socket feeds D1.
root(p).wires = root(p).wires.filter(x => x.id !== 'd0')
root(p).wires.push(w('cable', ['src', 'tx'], ['snk', 'rx']))
expect(checkCircuit(root(p), lookup(p)).some(i => i.text.includes('not connected'))).toBe(false)
})
it('splitting or joining a port leaves the pins of the other side where they are', () => {
const p = project()
const get = lookup(p)
for (const design of [undefined, { w: 6, h: 3 }]) {
p.components.find(d => d.id === 'source')!.design = design
const rows = (splitPorts?: string[]) => shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts }, get).inputs.filter(i => !i.port).map(i => [i.key, i.dy])
expect(rows(['tx'])).toEqual(rows())
}
// A side of single pins only is still centred when nothing is split.
p.components.find(d => d.id === 'source')!.design = undefined
p.components.find(d => d.id === 'source')!.nodes.push({ id: 'z', kind: 'output', x: 10, y: 10, label: 'Z' }, { id: 'z2', kind: 'output', x: 10, y: 12, label: 'Z2' })
expect(shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0 }, get).inputs.map(i => [i.key, i.dy])).toEqual([['a', 1], ['b', 2]])
})
it('lists the pins of the usual edge first, so a wire dropped on the box takes those', () => {
const p = project()
const get = lookup(p)
const snk = shapeOf({ id: 'n', kind: 'chip', chip: 'sink', x: 0, y: 0, splitPorts: ['rx'] }, get)
expect(snk.outputs.map(o => o.key)).toEqual(['x', 'y', 'rx.l2'])
const src = shapeOf({ id: 'n', kind: 'chip', chip: 'source', x: 0, y: 0, splitPorts: ['tx'] }, get)
expect(src.inputs.map(i => i.key)).toEqual(['a', 'b', 'tx.l2'])
})
it('a cable onto split lines only takes those on their usual edge, so its end never sits in the box', () => {
const p = project()
p.connectors![0]!.lines = [{ name: 'D0' }, { name: 'D1' }, { name: 'RX0', back: true }, { name: 'RX1', back: true }]
const r = root(p)
const get = lookup(p)
node(p, 'root', 'src').splitPorts = ['tx']
node(p, 'root', 'snk').splitPorts = ['rx']
// RX0 and RX1 run back: into the source on its right edge, out of the sink on its left.
expect(cableIntoPins(r, 'src', ['tx.l2', 'tx.l3'], get).ok).toBe(false)
expect(cableFromPins(r, 'snk', ['rx.l2', 'rx.l3'], get).ok).toBe(false)
// D0 and D1 leave the source on the right and enter the sink on the left: there a cable fits.
const src = node(p, 'root', 'src')
const out = cableFromPins(r, 'src', ['tx.l0', 'tx.l1'], get)
expect(out.ok && out.bundle.x).toBe(src.x + shapeOf(src, get).body.w)
const into = cableIntoPins(r, 'snk', ['rx.l0', 'rx.l1'], get)
expect(into.ok && into.split.x).toBe(node(p, 'root', 'snk').x - 1)
})
it('unpacking joins wires on split lines to the parts inside', () => {
const p = project()
const r = root(p)
node(p, 'root', 'snk').splitPorts = ['rx']
r.nodes.push({ id: 'lamp2', kind: 'lamp', x: 50, y: 4 })
r.wires.push(w('d0', ['sa', 'q'], ['snk', 'rx.l0']), w('xl', ['snk', 'x'], ['lamp', 'a']), w('hp', ['snk', 'rx.l2'], ['lamp2', 'a']))
const res = unpackChip(p, 'root', 'snk')
expect(res.ok && res.dropped).toBe(0)
for (const [a, h] of [[0, 1], [1, 0]] as const) {
const s = run(p, { sa: !!a, sh: !!h })
expect([s.pin('lamp', 'q'), s.pin('lamp2', 'q')]).toEqual([a, h])
}
})
it('unpacking says how many wires on lines had nowhere to go', () => {
const p = project()
p.components.push({
id: 'box',
name: 'Box',
symbol: 'box',
nodes: [
{ id: 'inner', kind: 'chip', chip: 'source', x: 6, y: 0 },
{ id: 'p2', kind: 'portout', conn: 'hdmi', x: 30, y: 0 },
],
wires: [w('b2', ['inner', 'tx'], ['p2', 'bus'])],
})
// D0 of the box comes from a part inside through a cable: no single wire inside to join it to.
root(p).nodes.push({ id: 'bx', kind: 'chip', chip: 'box', x: 6, y: 20, splitPorts: ['p2'] })
root(p).wires.push(w('l0', ['bx', 'p2.l0'], ['lamp', 'a']))
const res = unpackChip(p, 'root', 'bx')
expect(res.ok && res.dropped).toBe(1)
})
it('a docked panel made before ports moved to the top loses its row for the socket and lines up again', () => {
const p = project()
const r = root(p)
r.wires = r.wires.filter(x => x.id !== 'r3')
// As docked by earlier releases: a row for H and one for the socket below it, the port at the bottom.
r.nodes.push({ id: 'pan', kind: 'panel', x: 24, y: 0, attach: 'snk', rows: [{ id: 'h', type: 'switch', dy: 0 }, { id: 'rx', type: 'switch', dy: 1 }] })
r.wires.push(w('ph', ['pan', 'h'], ['snk', 'h']))
syncPanels(p)
pruneWires(p)
const pan = node(p, 'root', 'pan')
expect(pan.rows!.map(x => x.id)).toEqual(['h'])
const h = shapeOf(node(p, 'root', 'snk'), lookup(p)).inputs.find(i => i.key === 'h')!
expect(pan.y).toBe(node(p, 'root', 'snk').y + h.dy)
})
})