示例#1
0
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
示例#3
0
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)
示例#4
0
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)
示例#5
0
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)
示例#6
0
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)