def runall(self, compiler=None): """Compiles and runs each new or modified unit test executable. After the run is complete, the outcomes are checked for consistency. :arg compiler: the name of the compiler in 'compilers.xml' to use. """ #We will likely need a file comparer for the outcomes testing self.comparer = FileComparer(self.fortpy_templates, self.compare_templates) if self._written: self.set_compiler(compiler) from fortpy.testing.compilers import replace from fortpy.testing.auxiliary import generate from fortpy.utility import symlink from fortpy.code import config #Run them each individually and return a dictionary of all the #test results result = {} fpyauxs = [] for composite_id in self.tgenerator.tests_to_run: identifier, testid = composite_id.split("|") #Compile and copy fpy_auxiliary if it isn't in the identifiers directory yet. source = path.join(self.libraryroot(identifier), identifier) target = replace(source + ".[c]", self.compiler) if not path.isdir(target): from os import mkdir mkdir(target) if self.writer( identifier).autoclass and identifier not in fpyauxs: code, success, fpytarget = generate( self.parser, self._codefolder, self.libraryroot(identifier), self.compiler, self.debug, self.profile, self.strict) sopath = path.join(fpytarget, "fpy_aux.so") sotarget = path.join(target, "fpy_aux.so") mpath = path.join(fpytarget, "fpy_auxiliary.mod") mtarget = path.join(target, "fpy_auxiliary.mod") symlink(sopath, sotarget) symlink(mpath, mtarget) fpyauxs.append(identifier) oneresult = self._run_single(identifier, testid, source) if oneresult is not None: result[composite_id] = oneresult return result else: msg.warn( "you can't run tests until the executables have been written. Exiting." ) return None
def runall(self, compiler=None): """Compiles and runs each new or modified unit test executable. After the run is complete, the outcomes are checked for consistency. :arg compiler: the name of the compiler in 'compilers.xml' to use. """ #We will likely need a file comparer for the outcomes testing self.comparer = FileComparer(self.fortpy_templates, self.compare_templates) if self._written: self.set_compiler(compiler) from fortpy.testing.compilers import replace from fortpy.testing.auxiliary import generate from fortpy.utility import symlink from fortpy.code import config #Run them each individually and return a dictionary of all the #test results result = {} fpyauxs= [] for composite_id in self.tgenerator.tests_to_run: identifier, testid = composite_id.split("|") #Compile and copy fpy_auxiliary if it isn't in the identifiers directory yet. source = path.join(self.libraryroot(identifier), identifier) target = replace(source + ".[c]", self.compiler) if not path.isdir(target): from os import mkdir mkdir(target) if self.writer(identifier).autoclass and identifier not in fpyauxs: code, success, fpytarget = generate(self.parser, self._codefolder, self.libraryroot(identifier), self.compiler, self.debug, self.profile, self.strict) sopath = path.join(fpytarget, "fpy_aux.so") sotarget = path.join(target, "fpy_aux.so") mpath = path.join(fpytarget, "fpy_auxiliary.mod") mtarget = path.join(target, "fpy_auxiliary.mod") symlink(sopath, sotarget) symlink(mpath, mtarget) fpyauxs.append(identifier) oneresult = self._run_single(identifier, testid, source) if oneresult is not None: result[composite_id] = oneresult return result else: msg.warn("you can't run tests until the executables have been written. Exiting.") return None
def _ensure_fileversion(compiler, modname, folder, target, trycompile=True): """Makes sure that the module's f90, mod and o files are up to date with the template version. If they aren't compile and copy them. :arg compiler: the compiler key from compilers.xml :arg modname: the name of the module to check file versions for and move (e.g. "fortpy"). :arg folder: the folder that contains the up-to-date, "template" version of the module. :arg target: the folder to copy the compiled files to. :arg trycompile: if the codefile has not been compiled yet, or if the version is out of date, should the code try a simple compile? """ from os import path codefile = "{}.f90".format(modname) compfiles = ["{}.{}".format(modname, ext) for ext in ["o", "mod"]] tversion = template_version(compiler, codefile) for sdfile in compfiles: fdfile = replace(sdfile + ".[c]", compiler) ftarget = path.join(target, sdfile) dversion = get_fortpy_version(compiler, ftarget) if not path.isfile(ftarget) or dversion != tversion: source = path.join(folder, fdfile) sversion = get_fortpy_version(compiler, source) if trycompile and (not path.isfile(source) or sversion != tversion): _compile_simple(compiler, [modname], folder) _vupdate_compiled_module(compiler, modname, folder, tversion) elif not path.isfile(source): msg.warn("{} does not exist.".format(source)) continue elif sversion != tversion: msg.warn("{} has an old version number.".format(source)) from fortpy.utility import symlink symlink(source, ftarget) #If the file is a binary, we need to save a .v with version #information as well for the next time we want to copy it. pre, ext = path.splitext(ftarget) if ext in [".o", ".so", ".mod"]: with open(ftarget + '.v', 'w') as f: f.write("# <fortpy version=\"{}\" />".format('.'.join( map(str, tversion))))
def _ensure_fileversion(compiler, modname, folder, target, trycompile=True): """Makes sure that the module's f90, mod and o files are up to date with the template version. If they aren't compile and copy them. :arg compiler: the compiler key from compilers.xml :arg modname: the name of the module to check file versions for and move (e.g. "fortpy"). :arg folder: the folder that contains the up-to-date, "template" version of the module. :arg target: the folder to copy the compiled files to. :arg trycompile: if the codefile has not been compiled yet, or if the version is out of date, should the code try a simple compile? """ from os import path codefile = "{}.f90".format(modname) compfiles = ["{}.{}".format(modname, ext) for ext in ["o", "mod"]] tversion = template_version(compiler, codefile) for sdfile in compfiles: fdfile = replace(sdfile + ".[c]", compiler) ftarget = path.join(target, sdfile) dversion = get_fortpy_version(compiler, ftarget) if not path.isfile(ftarget) or dversion != tversion: source = path.join(folder, fdfile) sversion = get_fortpy_version(compiler, source) if trycompile and (not path.isfile(source) or sversion != tversion): _compile_simple(compiler, [modname], folder) _vupdate_compiled_module(compiler, modname, folder, tversion) elif not path.isfile(source): msg.warn("{} does not exist.".format(source)) continue elif sversion != tversion: msg.warn("{} has an old version number.".format(source)) from fortpy.utility import symlink symlink(source, ftarget) #If the file is a binary, we need to save a .v with version #information as well for the next time we want to copy it. pre, ext = path.splitext(ftarget) if ext in [".o", ".so", ".mod"]: with open(ftarget + '.v', 'w') as f: f.write("# <fortpy version=\"{}\" />".format('.'.join(map(str, tversion))))