def test_constructor(self):
"""
Test constructor with different parameters to ensure
that symbols and symbol directories are handled correctly.
"""
## get number of symbols in symbols directory
symbols = set()
for dummy, dummy, filenames in os.walk('upconvert/library/geda'):
for filename in filenames:
if filename.endswith('.sym'):
symbols.add(filename)
geda_parser = GEDA()
self.assertEquals(len(geda_parser.known_symbols), len(symbols))
geda_parser = GEDA([
'./test/geda/simple_example/symbols',
'/invalid/dir/gEDA',
])
self.assertEquals(len(geda_parser.known_symbols), len(symbols))
self.assertEquals(geda_parser.known_symbols['opamp'],
'./test/geda/simple_example/symbols/opamp.sym')
geda_parser = GEDA([
'test/geda/simple_example/symbols',
'/invalid/dir/gEDA',
])
self.assertTrue('title-B' in geda_parser.known_symbols)
geda_parser = GEDA()
self.assertTrue('title-B' in geda_parser.known_symbols)
def test_adding_license_text(self):
""" Test adding license text to design from GEDAText """
geda_text = GEDAText('BSD', attribute='use_license')
parser = GEDA()
design = upconvert.core.design.Design()
parser.add_text_to_design(design, geda_text)
self.assertEquals(design.design_attributes.metadata.license, 'BSD')
def test_adding_attribute_to_design(self):
""" Add regular attribute to design from GEDAText """
geda_text = GEDAText('some text', attribute='test_attr')
parser = GEDA()
design = upconvert.core.design.Design()
parser.add_text_to_design(design, geda_text)
self.assertEquals(design.design_attributes.attributes['test_attr'],
'some text')
def setUp(self):
"""
Set up a new GEDA parser with simplified setting for easier
testing. The scale factor is 10 and the origin is set to
(0, 0) for easier calculation of correct/converted values.
"""
self.geda_parser = GEDA()
## for easier validation
self.geda_parser.SCALE_FACTOR = 10
self.geda_parser.set_offset(upconvert.core.shape.Point(0, 0))
def test_parse_full(self):
"""
Test parsing a complete schematic file generating OpenJSON.
"""
self.geda_parser = GEDA([
'./test/geda/simple_example/symbols',
])
design = self.geda_parser.parse(
'test/geda/simple_example/simple_example.sch')
self.assertEquals(len(design.nets), 2)
net_names = [net.net_id for net in design.nets]
self.assertEquals(
sorted(net_names),
sorted(['+_1', '-_In+']),
)
def test_parse_component_data(self):
""" Tests parsing component data from symbol files and embedded
sections.
"""
self.geda_parser = GEDA([
'./test/geda/simple_example/symbols',
])
fpath = open('test/geda/path.sch')
component = self.geda_parser.parse_component_data(
fpath, {
'basename': 'test.sym',
})
fpath.close()
self.assertEquals(component.name, 'test')
self.assertEquals(len(component.symbols), 1)
self.assertEquals(len(component.symbols[0].bodies), 1)
self.assertEquals(len(component.symbols[0].bodies[0].shapes), 9)
def test_create_new_geda_parser(self):
""" Test creating an empty parser. """
parser = GEDA()
assert parser != None
def test_parse_title_frame(self):
""" Test parsing title frame components """
title_frames = {
'title-E': (44000, 34000),
'title-bordered-E': (44000, 34000),
'title-bordered-D': (34000, 22000),
'title-bordered-A': (11000, 8500),
'title-bordered-C': (22000, 17000),
'title-bordered-B': (17000, 11000),
'title-A0': (46800, 33100),
'title-A1': (33100, 23300),
'title-A2': (23300, 16500),
'title-A3': (16500, 11600),
'title-A4': (11600, 8200),
'title-A0-2': (46800, 33100),
'title-A1-2': (33100, 23300),
'title-A2-2': (23300, 16500),
'title-A3-2': (16500, 11600),
'title-A4-2': (11600, 8200),
'title-D': (34000, 22000),
'title-B': (17000, 11000),
'title-C': (22000, 17000),
'title-A': (11000, 8500),
'title-bordered-A4': (11600, 8200),
'title-bordered-A1': (33100, 23300),
'title-bordered-A0': (46800, 33100),
'title-bordered-A3': (16500, 11600),
'title-bordered-A2': (23300, 16500),
'title-dg-1': (17000, 11000),
'title-small-square': (7600, 6900),
'titleblock': (7500, 1800),
'titleblock1': (11000, 8500),
'titleblock2': (22000, 17000),
'titleblock3': (33000, 25500),
'titleblock4': (44000, 34000),
'title-B-nameOnEdge': (26600, 17000),
'title-B-cibolo': (26600, 17000),
'title-block': (7500, 1800),
}
params = {
'x': 3200,
'y': 3109,
}
geda_parser = GEDA()
for name, filename in geda_parser.known_symbols.items():
if name.startswith('title'):
params['basename'] = name
## reset geda parser
geda_parser.frame_width = 0
geda_parser.frame_height = 0
geda_parser.design = upconvert.core.design.Design()
geda_parser._parse_title_frame(params)
self.assertEquals(geda_parser.offset.x, params['x'])
self.assertEquals(geda_parser.offset.y, params['y'])
self.assertEquals(geda_parser.frame_width,
title_frames[name][0])
self.assertEquals(geda_parser.frame_height,
title_frames[name][1])
## check that method does not break when invalid file is passed
params['basename'] = 'invalid_symbol.sym'
geda_parser = GEDA()
geda_parser._parse_title_frame(params)
self.assertEquals(geda_parser.offset.x, params['x'])
self.assertEquals(geda_parser.offset.y, params['y'])
## check if default is set correctly
self.assertEquals(geda_parser.frame_width, 46800)
self.assertEquals(geda_parser.frame_height, 34000)
def test_parse(self):
""" Tests parsing valid and invalid schematic files. """
self.geda_parser = GEDA([
'test/geda/simple_example/symbols',
])
invalid_sch = open('/tmp/invalid.sch', 'w')
invalid_sch.write('C 18600 21500 1 0 0 EMBEDDED555-1')
invalid_sch.close()
self.assertRaises(GEDAError, self.geda_parser.parse,
'/tmp/invalid.sch')
## testing EMBEDDED component
design = self.geda_parser.parse('./test/geda/embedded_component.sch')
components = design.components.components #test components dictionary
self.assertEquals(components.keys(), ['EMBEDDEDbattery-1'])
component = components['EMBEDDEDbattery-1']
self.assertEquals(component.name, 'EMBEDDEDbattery-1')
keys = ['p1x', 'p1y', 'p2x', 'p2y', 'num', 'seq', 'label', 'type']
expected_pins = [
dict(zip(keys, [0, 200, 200, 200, '1', 1, '+', 'pwr'])),
dict(zip(keys, [700, 200, 500, 200, '2', 2, '-', 'pwr'])),
]
for pin, expected_pin in zip(component.symbols[0].bodies[0].pins,
expected_pins):
self.assertEquals(pin.label.text, expected_pin['label'])
## test reversed pin order due to different handling in direction
self.assertEquals(
pin.p1.x, expected_pin['p2x'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p1.y, expected_pin['p2y'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p2.x, expected_pin['p1x'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p2.y, expected_pin['p1y'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(pin.pin_number, expected_pin['num'])
## testing referenced component
design = self.geda_parser.parse('test/geda/component.sch')
components = design.components.components #test components dictionary
self.assertEquals(components.keys(), ['battery-1'])
component = components['battery-1']
self.assertEquals(component.name, 'battery-1')
keys = ['p1x', 'p1y', 'p2x', 'p2y', 'num', 'seq', 'label', 'type']
expected_pins = [
dict(zip(keys, [0, 200, 200, 200, '1', 1, '+', 'pwr'])),
dict(zip(keys, [700, 200, 500, 200, '2', 2, '-', 'pwr'])),
]
for pin, expected_pin in zip(component.symbols[0].bodies[0].pins,
expected_pins):
self.assertEquals(pin.label.text, expected_pin['label'])
## test reversed pin order due to different handling in direction
self.assertEquals(
pin.p1.x, expected_pin['p2x'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p1.y, expected_pin['p2y'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p2.x, expected_pin['p1x'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(
pin.p2.y, expected_pin['p1y'] / self.geda_parser.SCALE_FACTOR)
self.assertEquals(pin.pin_number, expected_pin['num'])
