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)