def test_length_3(self):
ed = EdififyNames()
l = list()
instance_1 = sdn.Instance()
name_1 = '&_'
for _ in range(ed.name_length_target - 2):
name_1 = name_1 + 'a'
instance_1.name = name_1
instance_2 = sdn.Instance()
name_2 = '&_'
for _ in range(ed.name_length_target - 9):
name_2 = name_2 + 'a'
name_2 = name_2 + '_sdn_1_'
instance_2.name = name_2
test_str = '$'
answer_str = '&_'
for _ in range(ed.name_length_target + 5):
test_str = test_str + 'a'
for _ in range(ed.name_length_target - 9):
answer_str = answer_str + 'a'
answer_str = answer_str + '_sdn_2_'
instance_3 = sdn.Instance()
instance_3.name = test_str
l = [instance_1, instance_2, instance_3]
assert ed.make_valid(instance_3, l) == answer_str
def test_duplicate_name(self):
ed = EdififyNames()
l = list()
i = sdn.Instance()
i.name = 'name'
i2 = sdn.Instance()
i2.name = 'name'
l = [i, i2]
assert ed.make_valid(i2, l) == "name_sdn_1_"
def test_duplicate_number_increment(self):
ed = EdififyNames()
l = list()
i = sdn.Instance()
i.name = 'name'
i_duplicate = sdn.Instance()
i_duplicate.name = 'name'
i2 = sdn.Instance()
i2.name = 'name_sdn_1_'
l = [i, i2, i_duplicate]
assert ed.make_valid(i_duplicate, l) == "name_sdn_2_"
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 setUpClass(cls) -> None:
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = definition.create_child()
instance.name = "MY_INST"
top_instance = sdn.Instance()
top_instance.name = "TOP_INST"
top_instance.reference = definition
netlist.top_instance = top_instance
cls.netlist = netlist
cls.library = library
cls.definition = definition
cls.instance = instance
cls.top_instance = top_instance
leaf_definition = library.create_definition()
leaf_cable = leaf_definition.create_cable()
leaf_wire = leaf_cable.create_wire()
instance.reference = leaf_definition
cls.leaf_definition = leaf_definition
cls.leaf_cable = leaf_cable
cls.leaf_wire = leaf_wire
cable = definition.create_cable()
wire = cable.create_wire()
port = definition.create_port()
pin = port.create_pin()
outer_pin = top_instance.pins[pin]
cls.cable = cable
cls.wire = wire
cls.port = port
cls.pin = pin
cls.outer_pin = outer_pin
def test_through_hierarchy(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
middle_inst = definition.create_child()
middle_def = library.create_definition()
middle_cable = middle_def.create_cable()
middle_wire = middle_cable.create_wire()
middle_inst.reference = middle_def
leaf_inst = middle_def.create_child()
leaf_def = library.create_definition()
leaf_inst.reference = leaf_def
top_inst_href = next(sdn.get_hinstances(netlist.top_instance))
hrefs = list(sdn.get_hcables(top_inst_href, recursive=True))
self.assertTrue(
len(hrefs) == 1
and all(isinstance(x.item, sdn.Cable) for x in hrefs))
hrefs = list(sdn.get_hcables(middle_inst))
self.assertTrue(
len(hrefs) == 1
and all(isinstance(x.item, sdn.Cable) for x in hrefs))
def test_simple_conversion(self):
ed = EdififyNames()
l = list()
i = sdn.Instance()
i.name = "name"
l = [i]
assert ed.make_valid(i, l) == "name"
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_top_instance(self):
self.assertIsNone(self.netlist.top_instance)
instance = sdn.Instance()
self.netlist.top_instance = instance
self.assertEqual(instance, self.netlist.top_instance)
self.netlist.top_instance = None
self.assertIsNone(self.netlist.top_instance)
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_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_invalid_name(self):
ed = EdififyNames()
l = list()
i = sdn.Instance()
i.name = "*this_is+an$*`id[0:3]"
l = [i]
assert ed.make_valid(
i, l) == "&_this_is_an___id_0_3_"
def test_pin_and_wire_chain(self):
netlist = sdn.Netlist()
netlist.name = "MY_NETLIST"
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
cable = definition.create_cable()
wire = cable.create_wire()
instance = sdn.Instance()
instance.name = "MY_INST"
instance.reference = definition
netlist.top_instance = instance
netlist_lookup = next(wire.get_netlists(), None)
self.assertIs(netlist, netlist_lookup)
cable.remove_wire(wire)
netlist_lookup = next(sdn.get_netlists(wire), None)
self.assertIsNone(netlist_lookup)
definition.remove_cable(cable)
netlist_lookup = next(sdn.get_netlists(cable), None)
self.assertIsNone(netlist_lookup)
outer_pin = instance.pins[pin]
netlist_lookup = next(sdn.get_netlists(outer_pin), None)
self.assertIs(netlist, netlist_lookup)
port.remove_pin(pin)
netlist_lookup = next(sdn.get_netlists(pin), None)
self.assertIsNone(netlist_lookup)
self.assertIsNone(outer_pin.inner_pin)
self.assertIsNone(outer_pin.instance)
top_instance_href = next(sdn.get_hinstances(netlist.top_instance))
netlist_lookup = next(sdn.get_netlists(top_instance_href))
self.assertIs(netlist, netlist_lookup)
definition.remove_port(port)
netlist_lookup = next(sdn.get_netlists(port), None)
self.assertIsNone(netlist_lookup)
instance.reference = None
netlist_lookup = next(sdn.get_netlists(instance), None)
self.assertIsNone(netlist_lookup)
library.remove_definition(definition)
netlist_lookup = next(sdn.get_netlists(definition), None)
self.assertIsNone(netlist_lookup)
netlist.remove_library(library)
netlist_lookup = next(sdn.get_netlists(library), None)
self.assertIsNone(netlist_lookup)
netlist_lookup = next(sdn.get_netlists(netlist, "MY_NETLIST"))
self.assertTrue(netlist is netlist_lookup)
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_get_cables_in_library(self):
library = sdn.Library()
definition = library.create_definition()
cable = definition.create_cable()
cable.name = "MY_PORT"
instance = sdn.Instance()
instance.reference = definition
port1 = next(library.get_cables("MY_PORT"))
self.assertEqual(cable, port1)
def test_get_ports_in_library(self):
library = sdn.Library()
definition = library.create_definition()
port = definition.create_port()
port.name = "MY_PORT"
instance = sdn.Instance()
instance.reference = definition
port1 = next(library.get_ports("MY_PORT"))
self.assertEqual(port, port1)
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_hash(self):
outer_pin = sdn.OuterPin()
self.assertEqual(hash(outer_pin), hash(self.pin))
inner_pin = sdn.InnerPin()
instance = sdn.Instance()
outer_pin1 = sdn.OuterPin.from_instance_and_inner_pin(
instance, inner_pin)
outer_pin2 = sdn.OuterPin.from_instance_and_inner_pin(
instance, inner_pin)
self.assertEqual(hash(outer_pin1), hash(outer_pin2))
def test_get_cables_in_netlist(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
cables = definition.create_cable()
cables.name = "MY_PORT"
instance = sdn.Instance()
instance.reference = definition
port1 = next(netlist.get_cables("MY_PORT"))
self.assertEqual(cables, port1)
def test_flyweight(self):
instance = sdn.Instance()
href1 = HRef.from_parent_and_item(None, instance)
href2 = HRef.from_parent_and_item(None, instance)
self.assertTrue(href1 is href2)
import weakref
w_href1 = weakref.ref(href1)
w_href2 = weakref.ref(href2)
href1 = None
href2 = None
import gc
gc.collect()
self.assertIsNone(w_href1())
self.assertIsNone(w_href2())
instance2 = sdn.Instance()
href1 = HRef.from_sequence([instance, instance2])
href2_parent = HRef(instance, None)
href2 = HRef.from_parent_and_item(href2_parent, instance2)
self.assertTrue(href1 is href2)
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_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_equal(self):
outer_pin = sdn.OuterPin()
self.assertEqual(outer_pin, self.pin)
inner_pin = sdn.InnerPin()
instance = sdn.Instance()
outer_pin1 = sdn.OuterPin.from_instance_and_inner_pin(
instance, inner_pin)
outer_pin2 = sdn.OuterPin.from_instance_and_inner_pin(
instance, inner_pin)
self.assertEqual(outer_pin1, outer_pin2)
self.assertNotEqual(self.pin, outer_pin1)
self.assertNotEqual(self.pin, None)
def test_length_2(self):
ed = EdififyNames()
l = list()
test_str = "$"
answer_str = "&_"
for _ in range(ed.name_length_target + 5):
test_str = test_str + 'a'
for _ in range(ed.name_length_target - 2):
answer_str = answer_str + 'a'
i = sdn.Instance()
i.name = test_str
l = [i]
assert ed.make_valid(i, l) == answer_str
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_is_unique(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition1 = library.create_definition()
instance1 = definition1.create_child()
definition2 = library.create_definition()
instance2a = definition2.create_child()
instance2a.reference = definition1
instance2b = definition2.create_child()
instance2b.reference = definition1
instance3 = sdn.Instance()
instance3.reference = definition2
netlist.top_instance = instance3
href1 = HRef.from_sequence([instance3, instance2a, instance1])
href2 = HRef.from_sequence([instance3, instance2b, instance1])
# Another test for test_flyweight stuffed in here :)
self.assertTrue(href1.parent.parent is href2.parent.parent)
self.assertTrue(href1.is_valid)
self.assertTrue(href2.is_valid)
self.assertFalse(href2.is_unique)
self.assertFalse(href1.is_unique)
definition2.remove_child(instance2b)
self.assertFalse(href2.is_valid)
self.assertFalse(href2.is_unique)
self.assertTrue(href1.is_unique)
definition4 = library.create_definition()
definition4.add_child(instance2b)
instance4 = sdn.Instance()
instance4.reference = definition4
definition2.add_child(instance4)
self.assertFalse(href1.is_unique)
def test_of_href_to_cable(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
cable = definition.create_cable()
wire = cable.create_wire()
wire.connect_pin(pin)
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
href = next(sdn.get_hcables(cable))
search = next(sdn.get_pins(href))
self.assertEqual(search, pin)
def test_get_all_hrefs_of_item(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
href = next(HRef.get_all_hrefs_of_item(instance))
self.assertTrue(href.item is instance)
href = next(HRef.get_all_hrefs_of_item(definition))
self.assertTrue(href.item is instance)
port = definition.create_port()
href = next(HRef.get_all_hrefs_of_item(port))
self.assertTrue(href.is_valid and href.item is port)
def test_href_str_and_repr(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
instance = sdn.Instance()
instance.reference = definition
netlist.top_instance = instance
cable = definition.create_cable()
cable.name = "MY_CABLE"
cable.create_wires(8)
href = HRef.from_sequence([instance, cable])
href_str = str(href)
self.assertTrue(href_str == "MY_CABLE")
href_repr = repr(href)
self.assertTrue(HRef.__name__ in href_repr)
self.assertTrue(cable.__class__.__name__ in href_repr)
def test_of_netlist_and_library_and_port(self):
netlist = sdn.Netlist()
library = netlist.create_library()
definition = library.create_definition()
port = definition.create_port()
pin = port.create_pin()
instance = sdn.Instance()
instance.reference = definition
search = next(netlist.get_pins())
self.assertEqual(search, pin)
search = next(sdn.get_pins(library))
self.assertEqual(search, pin)
search = next(sdn.get_pins(port))
self.assertEqual(search, pin)
