def compare_definition(self, definition_orig, definition_composer, check_identifier=True):
if check_identifier:
assert self.get_identifier(definition_orig) == self.get_identifier(definition_composer), \
"Definitions do not have the same identifier"
assert self.get_original_identifier(definition_orig) == self.get_original_identifier(definition_composer), \
"Definitions do not have the same original identifier"
assert len(definition_orig.ports) == len(definition_composer.ports), \
"Definitions do not have the same number of ports"
# for orig_port, composer_port in zip(definition_orig.ports, definition_composer.ports):
# self.compare_ports(orig_port, composer_port)
# do a smarter compare
for orig_port in definition_orig.ports:
if orig_port.name == None:
#ports with no name are not compared
print("WARNING: ports with name == None exist and are not compared")
continue
else:
patterns = orig_port.name
composer_port = next(sdn.get_ports(definition_composer, patterns))
self.compare_ports(orig_port, composer_port)
assert len(definition_orig.cables) == len(definition_composer.cables), \
"Definitions do not have the same number of cables"
for orig_cable in definition_orig.cables:
if orig_cable.name == None:
#ports with no name are not compared
print("WARNING: cables with name == None exist and are not compared")
continue
else:
patterns = orig_cable.name
composer_cable = next(sdn.get_cables(definition_composer, patterns))
self.compare_cables(orig_cable, composer_cable)
assert len(definition_orig.children) == len(definition_composer.children), \
"Definitions do not have the same number of instances"
# for orig_instance, composer_cable in zip(definition_orig.children, definition_composer.children):
# self.compare_instances(orig_instance, composer_cable)
for orig_instance in definition_orig.children:
if orig_instance.name == None:
#ports with no name are not compared
print("WARNING: children with name == None exist and are not compared")
continue
else:
if orig_instance.name.startswith("SDN_Assignment_"):
#skip assignment statements for now
continue
else:
patterns = orig_instance.name
try:
composer_instance = next(sdn.get_instances(definition_composer, patterns))
except Exception:
import pdb; pdb.set_trace()
self.compare_instances(orig_instance, composer_instance)
#compare assignemnt statements
pattern = "SDN_Assignment_*"
composer_generator = sdn.get_instances(definition_composer, pattern)
orig_generator = sdn.get_instances(definition_orig, pattern)
#i just need to make sure that they both contain the same number of each width assignment
composer_dict = dict()
orig_dict = dict()
ci = next(composer_generator, None)
while ci is not None:
num = ci.name.split("_")[3]
if num in composer_dict:
composer_dict[num] += 1
else:
composer_dict[num] = 1
ci = next(composer_generator, None)
oi = next(orig_generator, None)
while oi is not None:
num = oi.name.split("_")[3]
if num in orig_dict:
orig_dict[num] +=1
else:
orig_dict[num] = 1
oi = next(orig_generator, None)
for k in composer_dict.keys():
assert k in orig_dict and orig_dict[k] == composer_dict[k], "there are a different number of "+ str(k) + " width assignment"
def test_from_wire(self):
instance1 = next(sdn.get_instances(self.wire))
self.assertIs(self.top_instance, instance1)
def test_from_outer_pin(self):
instance1 = next(sdn.get_instances(self.outer_pin, "TOP_INST"))
self.assertIs(self.top_instance, instance1)
def test_from_instance_recursive(self):
instance1 = next(sdn.get_instances(self.top_instance, recursive=True))
self.assertEqual(self.instance, instance1)
def test_from_instance_outside_resursive(self):
instance1 = list(sdn.get_instances(self.instance, selection="OUTSIDE", recursive=True))
self.assertEqual(self.top_instance, instance1[0])
def test_get_instances_from_definition_recursive(self):
instance1 = list(sdn.get_instances(self.definition, recursive=True))
self.assertEqual(self.instance, instance1[0])
def test_from_leaf_definition_outside_recursive(self):
instance1 = list(sdn.get_instances(self.leaf_definition, selection="OUTSIDE", recursive=True))
self.assertEqual(len(instance1), 2)
self.assertTrue(self.top_instance in instance1 and self.instance in instance1)
def test_get_instances_from_library(self):
instance1 = next(sdn.get_instances(self.library))
self.assertEqual(self.instance, instance1)
def test_get_instances_from_netlist(self):
instance1 = next(sdn.get_instances(self.netlist))
self.assertEqual(self.instance, instance1)
def test_collection(self):
instances = list(sdn.get_instances([self.definition, self.definition]))
self.assertEqual(len(instances), 1)
def test_from_href_of_port(self):
port_href = next(sdn.get_hports(self.port))
instance1 = next(sdn.get_instances(port_href))
self.assertIs(self.top_instance, instance1)
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)
