def setUp(self):
self.definition_top = sdn.Definition()
self.port_top = self.definition_top.create_port()
self.inner_pin = self.port_top.create_pin()
self.cable = self.definition_top.create_cable()
self.wire = self.cable.create_wire()
self.definition_leaf = sdn.Definition()
self.port = self.definition_leaf.create_port()
self.pin1 = self.port.create_pin()
self.pin2 = self.port.create_pin()
self.instance = self.definition_top.create_child()
self.instance.reference = self.definition_leaf
def test_add_definition(self):
definition = sdn.Definition()
self.library.add_definition(definition)
self.assertTrue(definition in self.library.definitions)
self.assertEqual(definition.library, self.library)
self.assertEqual(list(self.library.definitions).count(definition), 1)
definition = sdn.Definition()
self.library.add_definition(definition, position=0)
self.assertTrue(definition in self.library.definitions)
self.assertEqual(definition.library, self.library)
self.assertEqual(list(self.library.definitions).count(definition), 1)
def test_post_assignment_pin_and_port_creation(self):
definition = sdn.Definition()
self.instance.reference = definition
port = definition.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
port2 = sdn.Port()
pin3 = port2.create_pin()
definition.add_port(port2)
pin4 = port2.create_pin()
outer_pin1 = self.instance.pins[pin1]
outer_pin2 = self.instance.pins[pin2]
outer_pin3 = self.instance.pins[pin3]
outer_pin4 = self.instance.pins[pin4]
wire = sdn.Wire()
wire.connect_pin(outer_pin1)
wire.connect_pin(outer_pin2)
wire.connect_pin(outer_pin3)
wire.connect_pin(outer_pin4)
inner_pins = [pin1, pin2, pin3, pin4]
outer_pins = [outer_pin1, outer_pin2, outer_pin3, outer_pin4]
for outer_pin, inner_pin in zip(outer_pins, inner_pins):
self.assertEqual(outer_pin.wire, wire)
self.assertTrue(outer_pin in wire.pins)
self.assertEqual(outer_pin.instance, self.instance)
self.assertEqual(outer_pin.inner_pin, inner_pin)
self.assertTrue(outer_pin in self.instance.pins)
self.assertTrue(inner_pin in self.instance.pins)
def test_library_name(self):
definition = sdn.Definition()
library = sdn.Library()
library.add_definition(definition)
self.assertTrue('Library.name undefined' in definition.__str__())
library.name = 'library'
self.assertTrue('Library.name \'library\'' in definition.__str__())
def setUp(self) -> None:
definition = sdn.Definition()
port = definition.create_port()
self.inner_pins = port.create_pins(10)
self.instance = sdn.Instance()
self.instance.reference = definition
self.outer_pins_view = self.instance.pins
def test_post_assignment_pin_and_port_removal(self):
definition = sdn.Definition()
port = definition.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
self.instance.reference = definition
outer_pin1 = self.instance.pins[pin1]
outer_pin2 = self.instance.pins[pin2]
wire = sdn.Wire()
wire.connect_pin(outer_pin1)
wire.connect_pin(outer_pin2)
port.remove_pin(pin1)
definition.remove_port(port)
self.assertIsNone(outer_pin1.wire)
self.assertIsNone(outer_pin1.instance)
self.assertIsNone(outer_pin1.inner_pin)
self.assertIsNone(outer_pin2.wire)
self.assertIsNone(outer_pin2.instance)
self.assertIsNone(outer_pin2.inner_pin)
self.assertFalse(outer_pin1 in wire.pins)
self.assertFalse(outer_pin2 in wire.pins)
self.assertFalse(outer_pin1 in self.instance.pins)
self.assertFalse(outer_pin2 in self.instance.pins)
self.assertFalse(pin1 in self.instance.pins)
self.assertFalse(pin2 in self.instance.pins)
def test_reference_assignment_with_pins(self):
definition = sdn.Definition()
port = definition.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
self.instance.reference = definition
self.assertTrue(pin1 in self.instance.pins)
self.assertTrue(pin2 in self.instance.pins)
outer_pin1 = self.instance.pins[pin1]
outer_pin2 = self.instance.pins[pin2]
self.assertIsInstance(outer_pin1, sdn.OuterPin)
self.assertIsInstance(outer_pin2, sdn.OuterPin)
self.assertEqual(outer_pin1.instance, self.instance)
self.assertEqual(outer_pin2.instance, self.instance)
self.assertEqual(outer_pin1.inner_pin, pin1)
self.assertEqual(outer_pin2.inner_pin, pin2)
wire = sdn.Wire()
wire.connect_pin(outer_pin1)
wire.connect_pin(outer_pin2)
self.instance.reference = None
self.assertEqual(len(self.instance.pins), 0)
self.assertIsNone(outer_pin1.wire)
self.assertIsNone(outer_pin2.wire)
self.assertIsNone(outer_pin1.instance)
self.assertIsNone(outer_pin2.instance)
self.assertIsNone(outer_pin2.inner_pin)
self.assertIsNone(outer_pin2.inner_pin)
def test_collection(self):
definition = sdn.Definition()
port = definition.create_port()
port.name = "MY_PORT"
instance = sdn.Instance()
instance.name = "MY_INST"
ports = list(sdn.get_ports([definition, instance]))
self.assertEqual(len(ports), 1)
def test_constructor(self):
self.assertIsInstance(self.definition, FirstClassElement,
"Definition is not an element.")
self.assertTrue(self.definition,
"Constructor returns None type or empty collection.")
definition2 = sdn.Definition()
self.assertNotEqual(self.definition, definition2,
"Unique objects are considered equal.")
def test_parameter_checking(self):
definition = sdn.Definition()
port = definition.create_port()
port.name = "MY_PORT"
self.assertRaises(TypeError, sdn.get_ports, definition, "MY_PORT", patterns="MY_PORT")
self.assertRaises(TypeError, sdn.get_ports, definition, "MY_PORT", unsupported_keyword=None)
self.assertRaises(TypeError, sdn.get_ports, None, "MY_PORT")
self.assertRaises(TypeError, sdn.get_ports, [None, definition], "MY_PORT")
def test_get_ports_on_instance(self):
definition = sdn.Definition()
port = definition.create_port()
port.name = "MY_PORT"
instance = sdn.Instance()
instance.reference = definition
port1 = next(instance.get_ports("MY_PORT"))
self.assertEqual(port, port1)
def test_parameter_checking(self):
definition = sdn.Definition()
instance = definition.create_child()
instance.name = "MY_INST"
self.assertRaises(TypeError, sdn.get_instances, definition, "MY_INST", patterns="MY_INST")
self.assertRaises(TypeError, sdn.get_instances, definition, "MY_INST", unsupported_keyword=None)
self.assertRaises(TypeError, sdn.get_instances, definition, "MY_INST", selection=sdn.BOTH)
self.assertRaises(TypeError, sdn.get_instances, None, "MY_INST")
self.assertRaises(TypeError, sdn.get_instances, [None, definition], "MY_INST")
def test_of_definition(self):
definition = sdn.Definition()
port = definition.create_port()
pin = port.create_pin()
instance = sdn.Instance()
instance.reference = definition
search = next(sdn.get_pins(definition))
self.assertEqual(search, pin)
def test_of_inner_pin_outside(self):
definition = sdn.Definition()
port = definition.create_port()
pin = port.create_pin()
instance = sdn.Instance()
instance.reference = definition
search = next(sdn.get_pins(pin, selection="OUTSIDE"))
self.assertEqual(search, instance.pins[pin])
def test_reference_reassignment(self):
definition = sdn.Definition()
port = definition.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
self.instance.reference = definition
self.assertTrue(self.instance in definition.references)
outer_pin1 = self.instance.pins[pin1]
outer_pin2 = self.instance.pins[pin2]
definition2 = sdn.Definition()
port = definition2.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
self.instance.reference = definition2
self.assertTrue(self.instance not in definition.references)
self.assertTrue(self.instance in definition2.references)
self.assertEqual(outer_pin1, self.instance.pins[pin1])
self.assertEqual(outer_pin2, self.instance.pins[pin2])
def test_href_equality(self):
top = sdn.Instance()
top_def = sdn.Definition()
top.reference = top_def
middle = top_def.create_child()
middle_def = sdn.Definition()
middle.reference = middle_def
leaf = middle_def.create_child()
leaf_def = sdn.Definition()
leaf.reference = leaf_def
sequence = [top, middle, leaf]
href1 = HRef.from_sequence(sequence)
href2 = HRef.from_sequence(sequence)
self.assertEqual(href1, href1)
self.assertNotEqual(href1, None)
self.assertEqual(href1, href2)
self.assertNotEqual(href1, href2.parent)
href3 = HRef.from_sequence(sequence[1:])
self.assertNotEqual(href1, href3)
def test_href_pin_name(self):
top = sdn.Instance()
top.name = "TOP"
top_def = sdn.Definition()
top.reference = top_def
port = top_def.create_port()
port.name = "PORT"
port.create_pins(1)
port.is_array = True
wire = port.pins[0]
sequence = [top, port, wire]
self.assertEqual("PORT[0]", HRef.from_sequence(sequence).name)
def test_parameter_checking(self):
definition = sdn.Definition()
cable = definition.create_cable()
cable.name = "MY_CABLE"
self.assertRaises(TypeError, sdn.get_pins, definition, "MY_CABLE")
self.assertRaises(TypeError,
sdn.get_pins,
definition,
unsupported_keyword=None)
self.assertRaises(TypeError, sdn.get_pins, definition, selection=None)
self.assertRaises(TypeError, sdn.get_pins, None)
self.assertRaises(TypeError, sdn.get_pins, [None, definition])
def test_href_wire_name(self):
top = sdn.Instance()
top.name = "TOP"
top_def = sdn.Definition()
top.reference = top_def
cable = top_def.create_cable()
cable.name = "CABLE"
cable.create_wires(1)
cable.is_array = True
wire = cable.wires[0]
sequence = [top, cable, wire]
self.assertEqual("CABLE[0]", HRef.from_sequence(sequence).name)
def test_get_port_instance_and_outer_pin(self):
definition = sdn.Definition()
port = definition.create_port()
pin = port.create_pin()
instance = sdn.Instance()
instance.reference = definition
search = next(sdn.get_ports(instance))
self.assertIs(port, search)
outer_pin = instance.pins[pin]
search = next(sdn.get_ports(outer_pin))
self.assertIs(port, search)
def test_instance_is_unique(self):
definition = sdn.Definition(name='a_definition')
instance_3 = sdn.Instance()
definition.add_child(instance_3)
instance_1 = sdn.Instance(name='instance_1')
instance_1.reference = definition
self.assertTrue(instance_1.is_unique())
instance_2 = sdn.Instance(name='instance_2')
instance_2.reference = definition
self.assertFalse(instance_1.is_unique())
self.assertFalse(instance_2.is_unique())
def test_reference_removal(self):
definition = sdn.Definition()
port = definition.create_port()
pin1 = port.create_pin()
pin2 = port.create_pin()
self.instance.reference = definition
self.assertTrue(self.instance in definition.references)
outer_pin1 = self.instance.pins[pin1]
outer_pin2 = self.instance.pins[pin2]
self.assertEqual(outer_pin1.inner_pin, pin1)
self.assertEqual(outer_pin2.inner_pin, pin2)
del self.instance.reference
self.assertTrue(self.instance not in definition.references)
self.assertIsNone(outer_pin1.inner_pin)
self.assertIsNone(outer_pin2.inner_pin)
def make_definition_copies(def_to_copy, num_of_copies):
copies = dict()
copies[def_to_copy] = collections.deque()
definition_copies[def_to_copy] = list()
for i in range(num_of_copies):
def_copy = sdn.Definition()
copy_definition(def_to_copy, def_copy, i)
definition_copies[def_to_copy].append(def_copy)
for y in range(len(def_to_copy.library.definitions)):
if def_to_copy == def_to_copy.library.definitions[y]:
break
try:
def_to_copy.library.add_definition(def_copy, y)
except KeyError:
name = def_to_copy['EDIF.identifier']
message = 'Try to add a definition with name of ' + name + 'but the name was already use'
raise KeyError(message)
definition_clean_up(def_to_copy)
return definition_copies
def test_multi_bit_add_out_of_order(self):
definition = sdn.Definition()
cable0 = sdn.Cable()
cable0.name = "net[0]"
cable0["EDIF.identifier"] = "net_0_"
cable1 = sdn.Cable()
cable1.name = "net[1]"
cable1["EDIF.identifier"] = "net_1_"
cable2 = sdn.Cable()
cable2.name = "net[2]"
cable2["EDIF.identifier"] = "net_2_"
cable0.create_wire()
cable1.create_wire()
cable2.create_wire()
p0 = sdn.InnerPin()
p1 = sdn.InnerPin()
p2 = sdn.InnerPin()
cable1.wires[0].connect_pin(p0)
cable1.wires[0].connect_pin(p1)
cable1.wires[0].connect_pin(p2)
ep = EdifParser()
ep.multibit_add_cable(definition, cable0)
ep.multibit_add_cable(definition, cable2)
ep.multibit_add_cable(definition, cable1)
assert len(definition.cables) == 1
assert len(definition.cables[0].wires) == 3
assert len(definition.cables[0].wires[0].pins) == 0
assert len(definition.cables[0].wires[1].pins) == 3
assert len(definition.cables[0].wires[2].pins) == 0
assert p0 in definition.cables[0].wires[1].pins
assert p1 in definition.cables[0].wires[1].pins
assert p2 in definition.cables[0].wires[1].pins
class TestPrint(unittest.TestCase):
netlist = sdn.Netlist(name='netlist')
cable = sdn.Cable(name='cable', is_downto=False)
instance = sdn.Instance()
print(netlist)
netlist.top_instance = instance
print(netlist)
print(cable)
print(instance)
library = netlist.create_library(name='lib')
print(library)
definition = sdn.Definition()
print(definition)
pin = sdn.Pin()
cable = sdn.Cable()
print(cable)
wire = cable.create_wire()
wire.connect_pin(pin)
print(pin)
print(wire)
port = sdn.Port()
port.direction = sdn.IN
print(port)
def test_remove_definitions_from_outside_library(self):
definition = sdn.Definition()
self.library.remove_definitions_from([definition])
def test_collection(self):
definition = sdn.Definition()
cable = definition.create_cable()
cable.name = "MY_CABLE"
cables = list(sdn.get_cables([definition, definition]))
self.assertEqual(len(cables), 1)
import spydrnet as sdn netlist = sdn.Netlist(name='netlist') cable = sdn.Cable(name='cable') instance = sdn.Instance() print(netlist) netlist.top_instance = instance print(netlist) print(cable) print(instance) library = netlist.create_library(name='lib') print(library) definition = sdn.Definition() print(definition) pin = sdn.Pin() cable = sdn.Cable() print(cable) wire = cable.create_wire() wire.connect_pin(pin) print(pin) print(wire) port = sdn.Port() port.direction = sdn.IN print(port)
def test_href_valid(self):
instance = sdn.Instance()
href = HRef.from_parent_and_item(None, instance)
self.assertFalse(href.is_valid)
definition = sdn.Definition()
instance.reference = definition
self.assertFalse(href.is_valid)
library = sdn.Library()
library.add_definition(definition)
self.assertFalse(href.is_valid)
netlist = sdn.Netlist()
netlist.add_library(library)
self.assertFalse(href.is_valid)
netlist.top_instance = instance
self.assertTrue(href.is_valid)
cable = sdn.Cable()
wire = sdn.Wire()
href = HRef.from_sequence([instance, cable, wire])
self.assertFalse(href.is_valid)
cable.add_wire(wire)
self.assertFalse(href.is_valid)
definition.add_cable(cable)
self.assertTrue(href.is_valid)
instance.reference = None
self.assertFalse(href.is_valid)
port = sdn.Port()
pin = sdn.InnerPin()
href = HRef.from_sequence([instance, port, pin])
self.assertFalse(href.is_valid)
port.add_pin(pin)
self.assertFalse(href.is_valid)
definition.add_port(port)
self.assertFalse(href.is_valid)
instance.reference = definition
self.assertTrue(href.is_valid)
higher_definition = library.create_definition()
higher_definition.add_child(instance)
self.assertTrue(href.is_valid)
higher_instance = sdn.Instance()
higher_instance.reference = higher_definition
netlist.top_instance = higher_instance
self.assertFalse(href.is_valid)
href = HRef.from_sequence([higher_instance, instance, cable, wire])
self.assertTrue(href.is_valid)
higher_instance.reference = None
self.assertFalse(href.is_valid)
higher_definition.remove_child(instance)
self.assertFalse(href.is_valid)
definition.remove_cable(cable)
self.assertFalse(href.is_valid)
cable.remove_wire(wire)
self.assertFalse(href.is_valid)
cable.add_wire(wire)
href = HRef.from_sequence([cable, wire])
self.assertFalse(href.is_valid)
cable.remove_wire(wire)
new_cable = sdn.Cable()
new_cable.add_wire(wire)
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, wire)
self.assertFalse(href.is_valid)
port.remove_pin(pin)
new_port = sdn.Port()
new_port.add_pin(pin)
href = HRef.from_sequence([port, pin])
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, pin)
self.assertFalse(href.is_valid)
href = HRef.from_parent_and_item(None, definition)
self.assertFalse(href.is_valid)
def test_set_top_instance_using_definition(self):
netlist = sdn.Netlist()
definition = sdn.Definition()
netlist.set_top_instance(definition)
self.assertTrue(netlist.top_instance.reference is definition)
