def test_fake_naming(files):
"""
Tests to determine if fparser is renaming contents and modules correctly.
Args:
files (list): Test files from which to read modules
"""
fortran_files = list()
for file in files:
file_code = file_reader(file)
fortran_files.append(fobjects.Ffile(file, file_code))
lib = fobjects.Flibrary(fortran_files)
for m in lib.modules:
assert m.fake_name != m.name, 'Module {} was renamed incorrectly to {}'.format(
m.name, m.fake_name)
for c in m.contents:
assert c.fake_name != c.name, '{} in {} was renamed incorrectly to {}'.format(
c.name, m.name, c.fake_name)
all_names = [m.name for m in lib.modules] + [m.fake_name for m in lib.modules] + \
[c.name for m in lib.modules for c in m.contents] + [c.fake_name for m in lib.modules for c in m.contents]
for a in all_names:
assert all_names.count(
a
) == 1, '{} hasn\'t been renamed correctly, it should appear only once in library but appears {}.'.format(
a, all_names.count(a))
def library_maker(files, comment_style='before', **kwargs):
"""
Makes a library out fortran files.
Args:
files (list): List of strings with the files directories.
comment_style (string): Style in which functions and subroutines are commented. 'after' or 'before'
default = 'before'
Kwargs:
terminal: Terminal in which to write what the program is doing and the problems its encountering.
Returns:
A Flibrary made up of all the fortran files.
"""
terminal_present = False
if 'terminal' in kwargs:
terminal_present = True
terminal = kwargs['terminal']
terminal.add_line('')
terminal.add_line('Generating Library...')
else:
print('Generating Library...')
fortran_files = list()
try:
for file_dir in files:
if terminal_present:
terminal.add_line('Reading file {}'.format(file_dir))
else:
print('Reading file {}'.format(file_dir))
file = open(file_dir, 'r')
file_code = file.readlines()
for i, line in enumerate(file_code):
file_code[i] = line.replace('\n', '')
file.close()
fortran_files.append(fobjects.Ffile(file_dir, fparsertools.multiple_and_remover(file_code), comment_style=comment_style))
Lib=fobjects.Flibrary(fortran_files)
if terminal_present:
terminal.add_line('Success: Library Generated')
else:
print('Success: Library Generated')
return Lib
except Exception as e:
if terminal_present:
terminal.add_line('Error: ' + str(e), number=2)
else:
print(e)
return None
def test_module_reader(file, module_names):
"""
Tests to determine if fparser is interpreting the modules names correctly.
Args:
file (string): Name of the Fortran File
module_names (list): Name of each module in the file
"""
file_code = file_reader(file)
fortran_file = fobjects.Ffile(file, file_code)
for module in module_names:
assert module in [
x.name for x in fortran_file.modules
], 'fparser could not find modoule {} within {}.'.format(module, file)
assert len(module_names) == len(
fortran_file.modules
), 'modules read by fparser in {} do not match number of modules expected.'.format(
file)
def test_dependecies_ordering(files, expected_order):
"""
Tests to determine if fparser is ordering modules correctly by number of dependencies and generating libraries correctly.
Args:
files (list): Test files from which to read modules
expected_order (list): Expected module order
"""
fortran_files = list()
for file in files:
file_code = file_reader(file)
fortran_files.append(fobjects.Ffile(file, file_code))
lib = fobjects.Flibrary(fortran_files)
assert len(expected_order) == len(
lib.modules
), 'Modules read by fparser in {} do not match number of Modules expected.'.format(
files)
for m, ex_m in zip(lib.modules, expected_order):
assert m.name == ex_m, 'Modules from files {} did not appear in the expected order'.format(
files)
def test_contains_reader(file, contents):
"""
Tests to determine if fparser is interpreting the contents names correctly.
Args:
file (string): Name of the Fortran File
contents (list): Name of each functional in the file
"""
file_code = file_reader(file)
fortran_file = fobjects.Ffile(file, file_code)
file_contents = list()
for m in fortran_file.modules:
file_contents += [x for x in m.contents]
for f in contents:
assert f in [
x.name for x in file_contents
], 'fparser could not find functional {} within {}.'.format(f, file)
assert len(contents) == len(
file_contents
), 'contents read by fparser in {} do not match number of contents expected.'.format(
file)
def test_interface_writer(files, module_names):
"""
Tests to determine if fparser is making interfaces from libraries correctly.
Args:
files (list): Test files from which to read modules.
module_names (list): Name of modules that ought to be in that interface.
"""
new_files = list()
for file_dir in files:
new_files.append(path_joining(file_dir))
lib = fparser.library_maker(new_files)
interface = fparser.interface_writer(lib, module_names)
interface_lines = interface.split('\n')
interface_file = fobjects.Ffile('interface', interface_lines)
assert len(interface_file.modules) == len(
module_names
), 'Number of Modules made in interface does not match number of modules expected.'
for m in interface_file.modules:
assert m.name in [
x.fake_name for x in lib.modules
], 'Modules made in interface {} is not within original library'.format(
m.name)