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)