def test_from_wire_and_cable(self):
library = self.netlist.libraries[1]
definition = library.definitions[0]
cable = definition.cables[0]
wire = cable.wires[0]
hrefs = list(sdn.get_hinstances(self.netlist.top_instance))
href_top = hrefs[0]
href_result = next(sdn.get_hinstances(wire))
self.assertTrue(href_top is href_result)
href_result = next(sdn.get_hinstances(cable))
self.assertTrue(href_top is href_result)
def test_get_hinstances_from_hrefs_of_port_and_pin(self):
library = self.netlist.libraries[0]
definition = library.definitions[0]
port = definition.ports[0]
pin = port.pins[0]
hrefs = list(sdn.get_hinstances(pin))
href = hrefs[0]
from spydrnet.util.hierarchical_reference import HRef
port_href = HRef.from_parent_and_item(href, port)
href_result = next(sdn.get_hinstances(port_href), None)
self.assertTrue(href_result is href)
pin_href = HRef.from_parent_and_item(port_href, pin)
href_result = next(sdn.get_hinstances(pin_href), None)
self.assertTrue(href_result is href)
def test_get_hinstances_from_hrefs_of_cable_and_wire(self):
library = self.netlist.libraries[1]
definition = library.definitions[0]
cable = definition.cables[0]
wire = cable.wires[0]
hrefs = list(sdn.get_hinstances(wire))
href_top = hrefs[0]
from spydrnet.util.hierarchical_reference import HRef
cable_href = HRef.from_parent_and_item(href_top, cable)
href_result = next(sdn.get_hinstances(cable_href), None)
self.assertTrue(href_result is href_top)
wire_href = HRef.from_parent_and_item(cable_href, wire)
href_result = next(sdn.get_hinstances(wire_href), None)
self.assertTrue(href_result is href_top)
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_get_hinstances_of_pin(self):
library = self.netlist.libraries[0]
definition = library.definitions[0]
port = definition.ports[0]
pin = port.pins[0]
hrefs = list(sdn.get_hinstances(pin))
self.assertTrue(len(hrefs) == 7)
def test_get_hinstances_of_wire(self):
library = self.netlist.libraries[1]
definition = library.definitions[0]
cable = definition.cables[0]
wire = cable.wires[0]
hrefs = list(sdn.get_hinstances(wire))
self.assertTrue(len(hrefs) == 1)
def test_from_outerpin(self):
library = self.netlist.libraries[1]
definition = library.definitions[0]
instance = definition.children[0]
outerpin = next(iter(instance.pins))
hrefs = list(sdn.get_hinstances(outerpin))
self.assertTrue(len(hrefs) == 1)
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_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_inst.reference = middle_def
leaf_inst = middle_def.create_child()
leaf_def = library.create_definition()
leaf_inst.reference = leaf_def
hrefs = list(sdn.get_hinstances(leaf_inst))
self.assertTrue(len(hrefs) == 1)
def test_recursive_memory_use(self):
netlist = sdn.load_example_netlist_by_name('leon3mp_hierarchical')
hrefs = list(sdn.get_hinstances(netlist))
self.assertTrue(len(hrefs) > 0)
def test_from_library(self):
hrefs = list(sdn.get_hinstances(self.netlist.libraries[0]))
self.assertTrue(len(hrefs) == 102)
def test_href(self):
href = next(sdn.get_hinstances(self.netlist.top_instance))
wires = list(sdn.get_wires(href, recursive=True))
self.assertEqual(len(wires), 6)
def test_from_href_of_instance(self):
href = next(sdn.get_hinstances(self.netlist.top_instance))
hrefs = list(sdn.get_hports(href))
self.assertTrue(len(hrefs) == 12 and all(isinstance(x.item, sdn.Port) for x in hrefs))
def test_get_hinstance_of_invalid_reference(self):
from spydrnet.util.hierarchical_reference import HRef
invalid_href = HRef.from_parent_and_item(None, None)
hrefs = list(sdn.get_hinstances(invalid_href))
self.assertTrue(len(hrefs) == 0)
def test_get_definition_from_href(self):
href = next(sdn.get_hinstances(self.netlist.top_instance))
definition_query = list(sdn.get_definitions(href))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.netlist.top_instance.reference)
def test_of_bad_instance(self):
hrefs = list(sdn.get_hinstances(sdn.Instance()))
self.assertTrue(len(hrefs) == 0)
def test_get_library_from_href(self):
href = next(sdn.get_hinstances(self.netlist.top_instance))
library_query = list(sdn.get_libraries(href))
self.assertTrue(
len(library_query) == 1
and library_query[0] == self.netlist.libraries[1])
def test_from_href_of_instance(self):
top_href = next(sdn.get_hinstances(self.netlist.top_instance))
instance1 = next(sdn.get_instances(top_href))
self.assertIs(self.top_instance, instance1)
def test_from_href_of_instance(self):
href = next(sdn.get_hinstances(self.netlist.top_instance))
hrefs = list(sdn.get_hwires(href))
self.assertTrue(len(hrefs) == 114)
def test_regex_search(self):
hrefs = list(
sdn.get_hinstances(self.netlist, '.*FSM_onehot.*', is_re=True))
self.assertTrue(len(hrefs) == 24)
