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_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_add_wire(self):
wire = sdn.Wire()
self.cable.add_wire(wire, position=0)
self.assertTrue(wire in self.cable.wires)
self.assertEqual(wire.cable, self.cable)
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_constructor(self):
self.assertFalse(isinstance(self.wire, FirstClassElement),
"Wire should not extend element")
wire2 = sdn.Wire()
self.assertNotEqual(self.wire, wire2,
"Unique items are considered equal")
def test_print_no_cable(self):
wire = sdn.Wire()
self.assertTrue('Not contained by any Cable' in wire.__str__())
