def test_get_definition_from_wire(self):
definition_query = list(
sdn.get_definitions(
self.netlist.top_instance.reference.cables[0].wires[0]))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.netlist.top_instance.reference)
def test_get_definition_of_library_outside(self):
definition_query = list(
sdn.get_definitions(self.netlist.libraries[0],
selection="OUTSIDE"))
self.assertTrue(
len(definition_query) == 1
and self.leaf_inst.reference not in definition_query)
def test_unique_query_return(self):
definition_query = list(
sdn.get_definitions([self.netlist.libraries[0], self.leaf_inst],
"leaf"))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.leaf_inst.reference)
def test_get_definition_of_definition_outside(self):
definition_query = list(
sdn.get_definitions(self.netlist.libraries[0].definitions[0],
selection="OUTSIDE"))
self.assertTrue(
len(definition_query) == 1 and definition_query[0]
== self.netlist.libraries[1].definitions[0])
def compare_libraries(self, library_orig, library_composer):
# try:
assert self.get_identifier(library_orig) == self.get_identifier(library_composer), \
"Libraries do not have the same identifier"
assert self.get_original_identifier(library_orig) == self.get_original_identifier(library_composer), \
"Libraries do not have the same original identifier"
assert len(library_orig.definitions) == len(library_composer.definitions), \
"Libraries do not have the same amount of definitions " \
+ str(library_orig) + " " + str(len(library_orig.definitions)) + " " +\
str(library_composer) + " " + \
str(len(library_composer.definitions))
# except Exception:
# import pdb; pdb.set_trace()
for orig_definition in library_orig.definitions:
if orig_definition.name == None:
# ports with no name are not compared
print(
"WARNING: definitions with name == None exist but are not compared"
)
continue
else:
patterns = orig_definition.name
composer_definition = next(
sdn.get_definitions(library_composer, patterns))
self.compare_definition(orig_definition, composer_definition)
def test_get_definition_of_library_recursive_absolute_pattern(self):
definition_query = list(
sdn.get_definitions(self.netlist.libraries[1],
"leaf",
recursive=True))
self.assertTrue(
len(definition_query) == 1
and self.leaf_inst.reference is definition_query[0])
def test_get_definition_of_instances_recursive_up(self):
definition_query = list(
sdn.get_definitions(self.leaf_inst,
selection="OUTSIDE",
recursive=True))
self.assertTrue(
len(definition_query) == 3
and self.leaf_inst.reference not in definition_query)
def test_get_definition_of_definition_inside_recursive(self):
definition_query = list(
sdn.get_definitions(self.netlist.top_instance.reference,
selection="INSIDE",
recursive=True))
self.assertTrue(
len(definition_query) == 3
and self.netlist.top_instance.reference not in definition_query)
def test_get_definition_of_instances_inside(self):
definition_query = list(
sdn.get_definitions(
self.netlist.libraries[0].definitions[0].references,
selection="INSIDE"))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.leaf_inst.reference)
def test_lookup_definition(self):
library = self.netlist.libraries[0]
definition = library.definitions[0]
definition_name = definition.name
def1 = next(self.netlist.get_definitions(definition_name))
self.assertEqual(definition, def1)
def2 = next(self.netlist.get_definitions(definition_name, key='EDIF.identifier'))
self.assertEqual(definition, def2)
def3 = next(sdn.get_definitions(self.netlist, definition_name))
self.assertEqual(definition, def3)
def4 = next(sdn.get_definitions(self.netlist, definition_name, key='EDIF.identifier'))
self.assertEqual(definition, def4)
def5 = next(library.get_definitions(definition_name))
self.assertEqual(definition, def5)
def6 = next(library.get_definitions(definition_name, key='EDIF.identifier'))
self.assertEqual(definition, def6)
def7 = next(sdn.get_definitions(library, definition_name))
self.assertEqual(definition, def7)
def8 = next(sdn.get_definitions(library, definition_name, key='EDIF.identifier'))
self.assertEqual(definition, def8)
def test_absolute_pattern_from_relative_query(self):
definition_query = list(sdn.get_definitions(self.leaf_inst, "leaf"))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.leaf_inst.reference)
def test_collection(self):
library = sdn.Library()
definition = library.create_definition()
definition.name = "MY_DEF"
ports = list(sdn.get_definitions([library, library]))
self.assertEqual(len(ports), 1)
def test_get_definition_of_library(self):
definition_query = list(sdn.get_definitions(self.netlist.libraries[1]))
self.assertTrue(
len(definition_query) == 3
and self.leaf_inst.reference not in definition_query)
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_get_definition_of_library_recursive(self):
definition_query = list(
sdn.get_definitions(self.netlist.libraries[1], recursive=True))
self.assertTrue(
len(definition_query) == 4
and self.leaf_inst.reference in definition_query)
def test_get_definition_from_inner_pins(self):
definition_query = list(
sdn.get_definitions(self.leaf_inst.reference.ports[0].pins[0]))
self.assertTrue(
len(definition_query) == 1
and definition_query[0] == self.leaf_inst.reference)
def test_get_definition_of_instances_recursive_down(self):
definition_query = set(
sdn.get_definitions(self.netlist.top_instance, recursive=True))
self.assertTrue(len(definition_query) == 4)