def test_write_component_to_file_symbol_dirs(self):
""" Tests writing a component to a symbol file with symbol dirs.
"""
sym_dir = '/tmp/sym'
if os.path.exists(sym_dir):
shutil.rmtree(sym_dir)
os.mkdir(sym_dir)
self.geda_writer = GEDA(
symbol_dirs=['test/geda/simple_example/symbols'])
self.geda_writer.component_library = dict()
self.geda_writer.project_dirs['symbol'] = sym_dir
geda_parser = upconvert.parser.geda.GEDA(
symbol_dirs=['test/geda/simple_example/symbols'])
converted_design = geda_parser.parse(
'test/geda/simple_example/simple_example.sch')
library_id = 'opamp'
component = converted_design.components.components[library_id]
self.geda_writer.write_component_to_file(library_id, component)
component_library = self.geda_writer.component_library
self.assertEquals(len(component_library), 1)
self.assertEquals(component_library, {
(library_id, 0): 'opamp.sym',
})
library_id = 'capacitor-1'
component = converted_design.components.components[library_id]
self.geda_writer.write_component_to_file(library_id, component)
component_library = self.geda_writer.component_library
self.assertEquals(len(component_library), 2)
self.assertEquals(component_library, {
('opamp', 0): 'opamp.sym',
(library_id, 0): 'capacitor-1.sym',
})
self.assertEquals(sorted(os.listdir(sym_dir)), [])
def test_write_schematic_file(self):
""" Reads the gEDA *simple_example* file into a design using the
gEDA parser, writes the result to a gEDA file and reads it into
a new design. Both designs are then compared regarding their
respective components, instances and nets. """
# pylint: disable=R0914
# pylint: disable=R0915
sym_dir = '/tmp/sym'
if os.path.exists('/tmp/converted.sch'):
os.remove('/tmp/converted.sch')
if os.path.exists(sym_dir):
shutil.rmtree(sym_dir)
geda_parser = upconvert.parser.geda.GEDA(
symbol_dirs=['test/geda/simple_example/symbols'])
geda_parser.set_offset(shape.Point(0, 0))
simple_design = geda_parser.parse(
'test/geda/simple_example/simple_example.sch')
geda_writer = GEDA()
geda_writer.write(simple_design, '/tmp/converted.sch')
converted_design = geda_parser.parse('/tmp/converted.sch')
## parse design again to make sure it is a clean slate
geda_parser = upconvert.parser.geda.GEDA(
symbol_dirs=['test/geda/simple_example/symbols'])
geda_parser.set_offset(shape.Point(0, 0))
simple_design = geda_parser.parse(
'test/geda/simple_example/simple_example.sch')
##compare nets
self.assertEquals(
sorted([(net.net_id, len(net.points))
for net in simple_design.nets]),
sorted([(net.net_id, len(net.points))
for net in converted_design.nets]))
snets = dict([(net.net_id, net) for net in simple_design.nets])
cnets = dict([(net.net_id, net) for net in converted_design.nets])
for snet_id, snet in snets.items():
cnet = cnets[snet_id]
spoints = dict([(pt.point_id, pt) for pt in snet.points.values()])
cpoints = dict([(pt.point_id, pt) for pt in cnet.points.values()])
self.assertEqual(sorted(spoints.keys()), sorted(cpoints.keys()))
for spoint_id, spoint in spoints.items():
cpoint = cpoints[spoint_id]
self.assertEquals(spoint.x, cpoint.x)
self.assertEquals(spoint.y, cpoint.y)
## compare component library
self.assertEqual(sorted(simple_design.components.components.keys()),
sorted(converted_design.components.components.keys()))
for lib_id in simple_design.components.components:
scomponent = simple_design.components.components[lib_id]
ccomponent = converted_design.components.components[lib_id]
self.assertEquals(scomponent.name, ccomponent.name)
self.assertEquals(scomponent.attributes, ccomponent.attributes)
self.assertEquals(len(scomponent.symbols), 1)
self.assertEquals(len(scomponent.symbols), len(ccomponent.symbols))
self.assertEquals(len(scomponent.symbols[0].bodies), 1)
self.assertEquals(len(scomponent.symbols[0].bodies),
len(ccomponent.symbols[0].bodies))
sbody = scomponent.symbols[0].bodies[0]
cbody = ccomponent.symbols[0].bodies[0]
## skip the unassigned shapes component as it adds an additional
## text from the basename when importing GEDA
if scomponent.name != 'UNASSIGNED_SHAPES':
self.assertEquals(len(sbody.shapes), len(cbody.shapes))
self.assertEquals(len(sbody.pins), len(cbody.pins))
for spin, cpin in zip(sbody.pins, cbody.pins):
self.assertEquals(spin.p1.x, cpin.p1.x)
self.assertEquals(spin.p1.x, cpin.p1.x)
self.assertEquals(spin.p2.y, cpin.p2.y)
self.assertEquals(spin.p2.y, cpin.p2.y)
if spin.label is None:
self.assertEquals(cpin.label, None)
else:
self.assertEquals(spin.label.text, cpin.label.text)
for sshape, cshape in zip(sbody.shapes, cbody.shapes):
self.assertEquals(sshape.type, cshape.type)
## compare component instances
scomp_instances = dict([(comp.instance_id, comp)
for comp in simple_design.component_instances])
ccomp_instances = dict([
(comp.instance_id, comp)
for comp in converted_design.component_instances
])
for instance_id in scomp_instances:
sinst = scomp_instances[instance_id]
cinst = ccomp_instances[instance_id]
self.assertEquals(sinst.instance_id, cinst.instance_id)
self.assertEquals(sinst.library_id, cinst.library_id)
self.assertEquals(sinst.symbol_index, cinst.symbol_index)
self.assertEquals(sinst.symbol_attributes[0].x,
cinst.symbol_attributes[0].x)
self.assertEquals(sinst.symbol_attributes[0].y,
cinst.symbol_attributes[0].y)
self.assertEquals(sinst.symbol_attributes[0].rotation,
cinst.symbol_attributes[0].rotation)
def setUp(self):
self.geda_writer = GEDA()
self.oj_parser = JSON()
