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)