logigate/tests/signals.test.ts

133 lines
5.5 KiB
TypeScript

import { describe, expect, it } from 'vitest'
import { nandCounts, stats } from '../app/lib/logic/analyze'
import { transistorBreakdown } from '../app/lib/logic/bulk'
import { compile } from '../app/lib/logic/compile'
import { chipPins } from '../app/lib/logic/geometry'
import { createProject, lookup, swapNode } from '../app/lib/logic/ops'
import { Simulator } from '../app/lib/logic/sim'
import type { ComponentDef, Project } from '../app/lib/logic/types'
function circuit(nodes: ComponentDef['nodes'], wires: ComponentDef['wires']): { p: Project; def: ComponentDef } {
const p = createProject({ examples: true })
const def: ComponentDef = { id: 'root', name: 'Root', symbol: 'box', nodes, wires }
p.components.push(def)
return { p, def }
}
const run = (p: Project, def: ComponentDef, on: Record<string, boolean>) => {
const s = new Simulator(compile(lookup(p), def.id))
for (const [k, v] of Object.entries(on)) s.setSource(k, v)
s.run()
return s
}
describe('named signals', () => {
it('a reference carries what is wired into the tag of its name, without a wire', () => {
const { p, def } = circuit(
[
{ id: 'clk', kind: 'input', x: 0, y: 0 },
{ id: 't', kind: 'tag', x: 4, y: 0, label: 'CLK' },
{ id: 'r1', kind: 'ref', x: 20, y: 10, label: 'CLK' },
{ id: 'r2', kind: 'ref', x: 20, y: 20, label: 'CLK' },
{ id: 'l1', kind: 'lamp', x: 30, y: 10 },
{ id: 'l2', kind: 'lamp', x: 30, y: 20 },
],
[
{ id: 'a', from: { node: 'clk', pin: 'q' }, to: { node: 't', pin: 'a' } },
{ id: 'b', from: { node: 'r1', pin: 'q' }, to: { node: 'l1', pin: 'a' } },
{ id: 'c', from: { node: 'r2', pin: 'q' }, to: { node: 'l2', pin: 'a' } },
],
)
expect(run(p, def, { clk: false }).pin('l1', 'a')).toBe(0)
const s = run(p, def, { clk: true })
expect([s.pin('l1', 'a'), s.pin('l2', 'a')]).toEqual([1, 1])
// Another name: nothing sends it, it reads 0.
def.nodes.find(n => n.id === 'r2')!.label = 'RESET'
expect(run(p, def, { clk: true }).pin('l2', 'a')).toBe(0)
})
it('names stay inside their circuit', () => {
const { p, def } = circuit(
[
{ id: 'sw', kind: 'input', x: 0, y: 0 },
{ id: 't', kind: 'tag', x: 4, y: 0, label: 'X' },
],
[{ id: 'a', from: { node: 'sw', pin: 'q' }, to: { node: 't', pin: 'a' } }],
)
const inner: ComponentDef = {
id: 'inner',
name: 'Inner',
symbol: 'box',
nodes: [
{ id: 'r', kind: 'ref', x: 0, y: 0, label: 'X' },
{ id: 'o', kind: 'output', x: 6, y: 0, label: 'Q' },
],
wires: [{ id: 'w', from: { node: 'r', pin: 'q' }, to: { node: 'o', pin: 'a' } }],
}
p.components.push(inner)
def.nodes.push({ id: 'c', kind: 'chip', chip: 'inner', x: 10, y: 0 }, { id: 'l', kind: 'lamp', x: 20, y: 0 })
def.wires.push({ id: 'b', from: { node: 'c', pin: 'o' }, to: { node: 'l', pin: 'a' } })
expect(run(p, def, { sw: true }).pin('l', 'a')).toBe(0)
})
})
describe('inverted inputs', () => {
it('a bubble inverts the input through one NAND, and the counts agree', () => {
const { p, def } = circuit(
[
{ id: 'a', kind: 'input', x: 0, y: 0 },
{ id: 'b', kind: 'input', x: 0, y: 3 },
{ id: 'g', kind: 'nand', x: 6, y: 0, invert: ['a'] },
{ id: 'l', kind: 'lamp', x: 14, y: 1, invert: ['a'] },
],
[
{ id: 'w1', from: { node: 'a', pin: 'q' }, to: { node: 'g', pin: 'a' } },
{ id: 'w2', from: { node: 'b', pin: 'q' }, to: { node: 'g', pin: 'b' } },
{ id: 'w3', from: { node: 'g', pin: 'q' }, to: { node: 'l', pin: 'a' } },
],
)
// g = NAND(!a, b); the lamp shows its inverse: AND(!a, b).
const table = [
[false, false],
[false, true],
[true, false],
[true, true],
].map(([a, b]) => run(p, def, { a: a!, b: b! }).pin('l', 'q'))
expect(table).toEqual([0, 1, 0, 0])
// The wire's own value shows on the pin, before the bubble.
expect(run(p, def, { a: true, b: false }).pin('g', 'a')).toBe(1)
const nl = compile(lookup(p), def.id)
expect(stats(nl).nands).toBe(3)
expect(nandCounts(p.components).get('root')).toBe(3)
const lines = transistorBreakdown(def, nandCounts(p.components), lookup(p))
expect(lines.find(l => l.key === 'invert')).toMatchObject({ count: 2, total: 8 })
})
it('swapping a part keeps its bubbles on the inputs in the same position', () => {
const { p, def } = circuit([{ id: 'g', kind: 'nand', x: 0, y: 0, invert: ['b'] }], [])
const or = p.components.find(d => d.id === 'ex-or')!
swapNode(p, def, 'g', { kind: 'chip', chip: or.id })
const g = def.nodes[0]!
const ins = chipPins(or).inputs.map(x => x.key)
expect(g.invert).toEqual([ins[1]])
swapNode(p, def, 'g', { kind: 'lamp' })
expect(g.invert).toBeUndefined()
})
it('bubbles on component inputs count inside every circuit that places it', () => {
const p = createProject({ examples: true })
const not = p.components.find(d => d.id === 'ex-not')!
const outer: ComponentDef = {
id: 'outer',
name: 'Outer',
symbol: 'box',
nodes: [{ id: 'c', kind: 'chip', chip: not.id, x: 0, y: 0, invert: [...new Set(['x', ...not.nodes.filter(n => n.kind === 'input').map(n => n.id)])] }],
wires: [],
}
p.components.push(outer)
const counts = nandCounts(p.components)
expect(counts.get('outer')).toBe(counts.get(not.id)! + 1)
expect(stats(compile(lookup(p), 'outer')).nands).toBe(counts.get('outer'))
})
})